vertx-lang-scala-docs_2.12 3.6.2 API - io.vertx.scala.redis.RedisClient

final def !=(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final def ##(): Int

Definition Classes: AnyRef → Any

final def ==(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def append(key: String, value: String, handler: Handler[AsyncResult[Long]]): RedisClient

Append a value to a key * @param key Key string

value: Value to append
handler: Handler for the result of this call.

def appendFuture(key: String, value: String): Future[Long]

Like append but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

final def asInstanceOf[T0]: T0

Definition Classes: Any

def asJava: AnyRef

def auth(password: String, handler: Handler[AsyncResult[String]]): RedisClient

Authenticate to the server * @param password Password for authentication

handler: Handler for the result of this call.

def authFuture(password: String): Future[String]

Like auth but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def bgrewriteaof(handler: Handler[AsyncResult[String]]): RedisClient

Asynchronously rewrite the append-only file

def bgrewriteaofFuture(): Future[String]

Like bgrewriteaof but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def bgsave(handler: Handler[AsyncResult[String]]): RedisClient

Asynchronously save the dataset to disk

def bgsaveFuture(): Future[String]

Like bgsave but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def bitcount(key: String, handler: Handler[AsyncResult[Long]]): RedisClient

Count set bits in a string * @param key Key string

handler: Handler for the result of this call.

def bitcountFuture(key: String): Future[Long]

Like bitcount but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def bitcountRange(key: String, start: Long, end: Long, handler: Handler[AsyncResult[Long]]): RedisClient

Count set bits in a string * @param key Key string

start: Start index
end: End index
handler: Handler for the result of this call.

def bitcountRangeFuture(key: String, start: Long, end: Long): Future[Long]

Like bitcountRange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def bitfield(key: String, bitFieldOptions: BitFieldOptions, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Perform arbitrary bitfield integer operations on strings.

Perform arbitrary bitfield integer operations on strings. * @param key Key string

def bitfieldFuture(key: String, bitFieldOptions: BitFieldOptions): Future[JsonArray]

Like bitfield but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def bitfieldWithOverflow(key: String, commands: BitFieldOptions, overflow: BitFieldOverflowOptions, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Perform arbitrary bitfield integer operations on strings.

Perform arbitrary bitfield integer operations on strings. * @param key Key string

def bitfieldWithOverflowFuture(key: String, commands: BitFieldOptions, overflow: BitFieldOverflowOptions): Future[JsonArray]

Like bitfieldWithOverflow but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def bitop(operation: BitOperation, destkey: String, keys: Buffer[String], handler: Handler[AsyncResult[Long]]): RedisClient

Perform bitwise operations between strings * @param operation Bitwise operation to perform

destkey: Destination key where result is stored
keys: List of keys on which to perform the operation
handler: Handler for the result of this call.

def bitopFuture(operation: BitOperation, destkey: String, keys: Buffer[String]): Future[Long]

Like bitop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def bitpos(key: String, bit: Int, handler: Handler[AsyncResult[Long]]): RedisClient

Find first bit set or clear in a string * @param key Key string

bit: What bit value to look for - must be 1, or 0
handler: Handler for the result of this call.

def bitposFrom(key: String, bit: Int, start: Int, handler: Handler[AsyncResult[Long]]): RedisClient

Find first bit set or clear in a string

See also bitposRange() method, which takes start, and stop offset. * @param key Key string

bit: What bit value to look for - must be 1, or 0
start: Start offset
handler: Handler for the result of this call.

def bitposFromFuture(key: String, bit: Int, start: Int): Future[Long]

Like bitposFrom but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def bitposFuture(key: String, bit: Int): Future[Long]

Like bitpos but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def bitposRange(key: String, bit: Int, start: Int, stop: Int, handler: Handler[AsyncResult[Long]]): RedisClient

Find first bit set or clear in a string

Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified * @param key Key string

bit: What bit value to look for - must be 1, or 0
start: Start offset
stop: End offset - inclusive
handler: Handler for the result of this call.

def bitposRangeFuture(key: String, bit: Int, start: Int, stop: Int): Future[Long]

Like bitposRange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def blpop(key: String, seconds: Int, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Remove and get the first element in a list, or block until one is available * @param key Key string identifying a list to watch

seconds: Timeout in seconds
handler: Handler for the result of this call.

def blpopFuture(key: String, seconds: Int): Future[JsonArray]

Like blpop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def blpopMany(keys: Buffer[String], seconds: Int, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Remove and get the first element in any of the lists, or block until one is available * @param keys List of key strings identifying lists to watch

seconds: Timeout in seconds
handler: Handler for the result of this call.

def blpopManyFuture(keys: Buffer[String], seconds: Int): Future[JsonArray]

Like blpopMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def brpop(key: String, seconds: Int, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Remove and get the last element in a list, or block until one is available * @param key Key string identifying a list to watch

seconds: Timeout in seconds
handler: Handler for the result of this call.

def brpopFuture(key: String, seconds: Int): Future[JsonArray]

Like brpop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def brpopMany(keys: Buffer[String], seconds: Int, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Remove and get the last element in any of the lists, or block until one is available * @param keys List of key strings identifying lists to watch

seconds: Timeout in seconds
handler: Handler for the result of this call.

def brpopManyFuture(keys: Buffer[String], seconds: Int): Future[JsonArray]

Like brpopMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def brpoplpush(key: String, destkey: String, seconds: Int, handler: Handler[AsyncResult[String]]): RedisClient

Pop a value from a list, push it to another list and return it; or block until one is available * @param key Key string identifying the source list

destkey: Key string identifying the destination list
seconds: Timeout in seconds
handler: Handler for the result of this call.

def brpoplpushFuture(key: String, destkey: String, seconds: Int): Future[String]

Like brpoplpush but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clientGetname(handler: Handler[AsyncResult[String]]): RedisClient

Get the current connection name

def clientGetnameFuture(): Future[String]

Like clientGetname but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clientKill(filter: KillFilter, handler: Handler[AsyncResult[Long]]): RedisClient

Kill the connection of a client * @param filter Filter options see KillFilter

handler: Handler for the result of this call.

def clientKillFuture(filter: KillFilter): Future[Long]

Like clientKill but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clientList(handler: Handler[AsyncResult[String]]): RedisClient

Get the list of client connections

def clientListFuture(): Future[String]

Like clientList but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clientPause(millis: Long, handler: Handler[AsyncResult[String]]): RedisClient

Stop processing commands from clients for some time * @param millis Pause time in milliseconds

handler: Handler for the result of this call.

def clientPauseFuture(millis: Long): Future[String]

Like clientPause but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clientReply(options: ClientReplyOptions, handler: Handler[AsyncResult[String]]): RedisClient

Instruct the server whether to reply to commands.

def clientReplyFuture(options: ClientReplyOptions): Future[String]

Like clientReply but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clientSetname(name: String, handler: Handler[AsyncResult[String]]): RedisClient

Set the current connection name * @param name New name for current connection

handler: Handler for the result of this call.

def clientSetnameFuture(name: String): Future[String]

Like clientSetname but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clone(): AnyRef

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @native() @throws( ... )

def close(handler: Handler[AsyncResult[Unit]]): Unit

Close the client - when it is fully closed the handler will be called.

def closeFuture(): Future[Unit]

Like close but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterAddslots(slots: Buffer[Long], handler: Handler[AsyncResult[Unit]]): RedisClient

Assign new hash slots to receiving node.

Assign new hash slots to receiving node. * @param handler Handler for the result of this call.

def clusterAddslotsFuture(slots: Buffer[Long]): Future[Unit]

Like clusterAddslots but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterCountFailureReports(nodeId: String, handler: Handler[AsyncResult[Long]]): RedisClient

Return the number of failure reports active for a given node.

Return the number of failure reports active for a given node. * @param handler Handler for the result of this call.

def clusterCountFailureReportsFuture(nodeId: String): Future[Long]

Like clusterCountFailureReports but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterCountkeysinslot(slot: Long, handler: Handler[AsyncResult[Long]]): RedisClient

Return the number of local keys in the specified hash slot.

Return the number of local keys in the specified hash slot. * @param handler Handler for the result of this call.

def clusterCountkeysinslotFuture(slot: Long): Future[Long]

Like clusterCountkeysinslot but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterDelslots(slot: Long, handler: Handler[AsyncResult[Unit]]): RedisClient

Set hash slots as unbound in receiving node.

Set hash slots as unbound in receiving node. * @param handler Handler for the result of this call.

def clusterDelslotsFuture(slot: Long): Future[Unit]

Like clusterDelslots but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterDelslotsMany(slots: Buffer[Long], handler: Handler[AsyncResult[Unit]]): RedisClient

Set hash slots as unbound in receiving node.

Set hash slots as unbound in receiving node. * @param handler Handler for the result of this call.

def clusterDelslotsManyFuture(slots: Buffer[Long]): Future[Unit]

Like clusterDelslotsMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterFailOverWithOptions(options: FailoverOptions, handler: Handler[AsyncResult[Unit]]): RedisClient

Forces a slave to perform a manual failover of its master.

Forces a slave to perform a manual failover of its master. * @param handler Handler for the result of this call.

def clusterFailOverWithOptionsFuture(options: FailoverOptions): Future[Unit]

Like clusterFailOverWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterFailover(handler: Handler[AsyncResult[Unit]]): RedisClient

Forces a slave to perform a manual failover of its master.

Forces a slave to perform a manual failover of its master. * @param handler Handler for the result of this call.

def clusterFailoverFuture(): Future[Unit]

Like clusterFailover but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterForget(nodeId: String, handler: Handler[AsyncResult[Unit]]): RedisClient

Remove a node from the nodes table.

Remove a node from the nodes table. * @param handler Handler for the result of this call.

def clusterForgetFuture(nodeId: String): Future[Unit]

Like clusterForget but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterGetkeysinslot(slot: Long, count: Long, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Return local key names in the specified hash slot.

Return local key names in the specified hash slot. * @param handler Handler for the result of this call.

def clusterGetkeysinslotFuture(slot: Long, count: Long): Future[JsonArray]

Like clusterGetkeysinslot but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterInfo(handler: Handler[AsyncResult[JsonArray]]): RedisClient

Provides info about Redis Cluster node state.

Provides info about Redis Cluster node state. * @param handler Handler for the result of this call.

def clusterInfoFuture(): Future[JsonArray]

Like clusterInfo but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterKeyslot(key: String, handler: Handler[AsyncResult[Long]]): RedisClient

Returns the hash slot of the specified key.

Returns the hash slot of the specified key. * @param handler Handler for the result of this call.

def clusterKeyslotFuture(key: String): Future[Long]

Like clusterKeyslot but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterMeet(ip: String, port: Long, handler: Handler[AsyncResult[Unit]]): RedisClient

Force a node cluster to handshake with another node.

Force a node cluster to handshake with another node. * @param handler Handler for the result of this call.

def clusterMeetFuture(ip: String, port: Long): Future[Unit]

Like clusterMeet but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterNodes(handler: Handler[AsyncResult[JsonArray]]): RedisClient

Get Cluster config for the node.

Get Cluster config for the node. * @param handler Handler for the result of this call.

def clusterNodesFuture(): Future[JsonArray]

Like clusterNodes but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterReplicate(nodeId: String, handler: Handler[AsyncResult[Unit]]): RedisClient

Reconfigure a node as a slave of the specified master node.

Reconfigure a node as a slave of the specified master node. * @param handler Handler for the result of this call.

def clusterReplicateFuture(nodeId: String): Future[Unit]

Like clusterReplicate but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterReset(handler: Handler[AsyncResult[Unit]]): RedisClient

Reset a Redis Cluster node.

Reset a Redis Cluster node. * @param handler Handler for the result of this call.

def clusterResetFuture(): Future[Unit]

Like clusterReset but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterResetWithOptions(options: ResetOptions, handler: Handler[AsyncResult[Unit]]): RedisClient

Reset a Redis Cluster node.

Reset a Redis Cluster node. * @param handler Handler for the result of this call.

def clusterResetWithOptionsFuture(options: ResetOptions): Future[Unit]

Like clusterResetWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterSaveconfig(handler: Handler[AsyncResult[Unit]]): RedisClient

Forces the node to save cluster state on disk.

Forces the node to save cluster state on disk. * @param handler Handler for the result of this call.

def clusterSaveconfigFuture(): Future[Unit]

Like clusterSaveconfig but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterSetConfigEpoch(epoch: Long, handler: Handler[AsyncResult[Unit]]): RedisClient

Set the configuration epoch in a new node.

Set the configuration epoch in a new node. * @param handler Handler for the result of this call.

def clusterSetConfigEpochFuture(epoch: Long): Future[Unit]

Like clusterSetConfigEpoch but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterSetslot(slot: Long, subcommand: SlotCmd, handler: Handler[AsyncResult[Unit]]): RedisClient

Bind an hash slot to a specific node.

Bind an hash slot to a specific node. * @param handler Handler for the result of this call.

def clusterSetslotFuture(slot: Long, subcommand: SlotCmd): Future[Unit]

Like clusterSetslot but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterSetslotWithNode(slot: Long, subcommand: SlotCmd, nodeId: String, handler: Handler[AsyncResult[Unit]]): RedisClient

Bind an hash slot to a specific node.

Bind an hash slot to a specific node. * @param handler Handler for the result of this call.

def clusterSetslotWithNodeFuture(slot: Long, subcommand: SlotCmd, nodeId: String): Future[Unit]

Like clusterSetslotWithNode but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterSlaves(nodeId: String, handler: Handler[AsyncResult[JsonArray]]): RedisClient

List slave nodes of the specified master node.

List slave nodes of the specified master node. * @param handler Handler for the result of this call.

def clusterSlavesFuture(nodeId: String): Future[JsonArray]

Like clusterSlaves but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clusterSlots(handler: Handler[AsyncResult[JsonArray]]): RedisClient

Get array of Cluster slot to node mappings

def clusterSlotsFuture(): Future[JsonArray]

Like clusterSlots but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def command(handler: Handler[AsyncResult[JsonArray]]): RedisClient

Get array of Redis command details

def commandCount(handler: Handler[AsyncResult[Long]]): RedisClient

Get total number of Redis commands

def commandCountFuture(): Future[Long]

Like commandCount but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def commandFuture(): Future[JsonArray]

Like command but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def commandGetkeys(handler: Handler[AsyncResult[JsonArray]]): RedisClient

Extract keys given a full Redis command

def commandGetkeysFuture(): Future[JsonArray]

Like commandGetkeys but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def commandInfo(commands: Buffer[String], handler: Handler[AsyncResult[JsonArray]]): RedisClient

Get array of specific Redis command details * @param commands List of commands to get info for

handler: Handler for the result of this call.

def commandInfoFuture(commands: Buffer[String]): Future[JsonArray]

Like commandInfo but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def configGet(parameter: String, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Get the value of a configuration parameter * @param parameter Configuration parameter

handler: Handler for the result of this call.

def configGetFuture(parameter: String): Future[JsonArray]

Like configGet but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def configResetstat(handler: Handler[AsyncResult[String]]): RedisClient

Reset the stats returned by INFO

def configResetstatFuture(): Future[String]

Like configResetstat but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def configRewrite(handler: Handler[AsyncResult[String]]): RedisClient

Rewrite the configuration file with the in memory configuration

def configRewriteFuture(): Future[String]

Like configRewrite but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def configSet(parameter: String, value: String, handler: Handler[AsyncResult[String]]): RedisClient

Set a configuration parameter to the given value * @param parameter Configuration parameter

value: New value
handler: Handler for the result of this call.

def configSetFuture(parameter: String, value: String): Future[String]

Like configSet but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def dbsize(handler: Handler[AsyncResult[Long]]): RedisClient

Return the number of keys in the selected database

def dbsizeFuture(): Future[Long]

Like dbsize but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def debugObject(key: String, handler: Handler[AsyncResult[String]]): RedisClient

Get debugging information about a key * @param key Key string

handler: Handler for the result of this call.

def debugObjectFuture(key: String): Future[String]

Like debugObject but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def debugSegfault(handler: Handler[AsyncResult[String]]): RedisClient

Make the server crash

def debugSegfaultFuture(): Future[String]

Like debugSegfault but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def decr(key: String, handler: Handler[AsyncResult[Long]]): RedisClient

Decrement the integer value of a key by one * @param key Key string

handler: Handler for the result of this call.

def decrFuture(key: String): Future[Long]

Like decr but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def decrby(key: String, decrement: Long, handler: Handler[AsyncResult[Long]]): RedisClient

Decrement the integer value of a key by the given number * @param key Key string

decrement: Value by which to decrement
handler: Handler for the result of this call.

def decrbyFuture(key: String, decrement: Long): Future[Long]

Like decrby but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def del(key: String, handler: Handler[AsyncResult[Long]]): RedisClient

Delete a key * @param key Keys to delete

handler: Handler for the result of this call.

def delFuture(key: String): Future[Long]

Like del but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def delMany(keys: Buffer[String], handler: Handler[AsyncResult[Long]]): RedisClient

Delete many keys * @param keys List of keys to delete

handler: Handler for the result of this call.

def delManyFuture(keys: Buffer[String]): Future[Long]

Like delMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def dump(key: String, handler: Handler[AsyncResult[String]]): RedisClient

Return a serialized version of the value stored at the specified key.

Return a serialized version of the value stored at the specified key. * @param key Key string

handler: Handler for the result of this call.

def dumpFuture(key: String): Future[String]

Like dump but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def echo(message: String, handler: Handler[AsyncResult[String]]): RedisClient

Echo the given string * @param message String to echo

handler: Handler for the result of this call.

def echoFuture(message: String): Future[String]

Like echo but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def equals(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def eval(script: String, keys: Buffer[String], args: Buffer[String], handler: Handler[AsyncResult[JsonArray]]): RedisClient

Execute a Lua script server side.

Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.

When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String. * @param script Lua script to evaluate

keys: List of keys
args: List of argument values
handler: Handler for the result of this call.

def evalFuture(script: String, keys: Buffer[String], args: Buffer[String]): Future[JsonArray]

Like eval but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def evalScript(script: Script, keys: Buffer[String], args: Buffer[String], handler: Handler[AsyncResult[JsonArray]]): RedisClient

Execute a Lua script server side.

Execute a Lua script server side. This method is a high level wrapper around EVAL and EVALSHA using the latter if possible, falling back to EVAL if the script is not cached by the server yet. According to Redis documentation, executed scripts are guaranteed to be in the script cache of a given execution of a Redis instance forever, which means typically the overhead incurred by optimistically sending EVALSHA is minimal, while improving performance and saving bandwidth compared to using EVAL every time. * @param script Lua script and its SHA1 digest

keys: List of keys
args: List of argument values
handler: Handler for the result of this call. group: scripting

def evalScriptFuture(script: Script, keys: Buffer[String], args: Buffer[String]): Future[JsonArray]

Like evalScript but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def evalsha(sha1: String, keys: Buffer[String], values: Buffer[String], handler: Handler[AsyncResult[JsonArray]]): RedisClient

Execute a Lua script server side.

Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.

When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String. * @param sha1 SHA1 digest of the script cached on the server

keys: List of keys
values: List of values
handler: Handler for the result of this call.

def evalshaFuture(sha1: String, keys: Buffer[String], values: Buffer[String]): Future[JsonArray]

Like evalsha but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def exists(key: String, handler: Handler[AsyncResult[Long]]): RedisClient

Determine if a key exists * @param key Key string

handler: Handler for the result of this call.

def existsFuture(key: String): Future[Long]

Like exists but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def existsMany(keys: Buffer[String], handler: Handler[AsyncResult[Long]]): RedisClient

Determine if one or many keys exist * @param keys List of key strings

handler: Handler for the result of this call.

def existsManyFuture(keys: Buffer[String]): Future[Long]

Like existsMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def expire(key: String, seconds: Long, handler: Handler[AsyncResult[Long]]): RedisClient

Set a key's time to live in seconds * @param key Key string

seconds: Time to live in seconds
handler: Handler for the result of this call.

def expireFuture(key: String, seconds: Long): Future[Long]

Like expire but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def expireat(key: String, seconds: Long, handler: Handler[AsyncResult[Long]]): RedisClient

Set the expiration for a key as a UNIX timestamp * @param key Key string

seconds: Expiry time as Unix timestamp in seconds
handler: Handler for the result of this call.

def expireatFuture(key: String, seconds: Long): Future[Long]

Like expireat but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def finalize(): Unit

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @throws( classOf[java.lang.Throwable] )

def flushall(handler: Handler[AsyncResult[String]]): RedisClient

Remove all keys from all databases

def flushallFuture(): Future[String]

Like flushall but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def flushdb(handler: Handler[AsyncResult[String]]): RedisClient

Remove all keys from the current database

def flushdbFuture(): Future[String]

Like flushdb but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def geoadd(key: String, longitude: Double, latitude: Double, member: String, handler: Handler[AsyncResult[Long]]): RedisClient

Add one or more geospatial items in the geospatial index represented using a sorted set.

Add one or more geospatial items in the geospatial index represented using a sorted set. * @param key Key string

longitude: longitude
latitude: latitude
member: member
handler: Handler for the result of this call.

def geoaddFuture(key: String, longitude: Double, latitude: Double, member: String): Future[Long]

Like geoadd but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def geoaddMany(key: String, members: Buffer[GeoMember], handler: Handler[AsyncResult[Long]]): RedisClient

Add one or more geospatial items in the geospatial index represented using a sorted set.

Add one or more geospatial items in the geospatial index represented using a sorted set. * @param key Key string

members: list of <lon, lat, member>
handler: Handler for the result of this call.

def geoaddManyFuture(key: String, members: Buffer[GeoMember]): Future[Long]

Like geoaddMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def geodist(key: String, member1: String, member2: String, handler: Handler[AsyncResult[String]]): RedisClient

Return the distance between two members in the geospatial index represented by the sorted set.

Return the distance between two members in the geospatial index represented by the sorted set. * @param key Key string

member1: member 1
member2: member 2
handler: Handler for the result of this call.

def geodistFuture(key: String, member1: String, member2: String): Future[String]

Like geodist but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def geodistWithUnit(key: String, member1: String, member2: String, unit: GeoUnit, handler: Handler[AsyncResult[String]]): RedisClient

Return the distance between two members in the geospatial index represented by the sorted set.

Return the distance between two members in the geospatial index represented by the sorted set. * @param key Key string

member1: member 1
member2: member 2
unit: geo unit
handler: Handler for the result of this call.

def geodistWithUnitFuture(key: String, member1: String, member2: String, unit: GeoUnit): Future[String]

Like geodistWithUnit but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def geohash(key: String, member: String, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).

Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD). * @param key Key string

member: member
handler: Handler for the result of this call.

def geohashFuture(key: String, member: String): Future[JsonArray]

Like geohash but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def geohashMany(key: String, members: Buffer[String], handler: Handler[AsyncResult[JsonArray]]): RedisClient

Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).

Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD). * @param key Key string

members: list of members
handler: Handler for the result of this call.

def geohashManyFuture(key: String, members: Buffer[String]): Future[JsonArray]

Like geohashMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def geopos(key: String, member: String, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.

Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key. * @param key Key string

member: member
handler: Handler for the result of this call.

def geoposFuture(key: String, member: String): Future[JsonArray]

Like geopos but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def geoposMany(key: String, members: Buffer[String], handler: Handler[AsyncResult[JsonArray]]): RedisClient

Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.

Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key. * @param key Key string

members: list of members
handler: Handler for the result of this call.

def geoposManyFuture(key: String, members: Buffer[String]): Future[JsonArray]

Like geoposMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def georadius(key: String, longitude: Double, latitude: Double, radius: Double, unit: GeoUnit, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).

Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius). * @param key Key string

longitude: longitude
latitude: latitude
radius: radius
unit: geo unit
handler: Handler for the result of this call.

def georadiusFuture(key: String, longitude: Double, latitude: Double, radius: Double, unit: GeoUnit): Future[JsonArray]

Like georadius but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def georadiusWithOptions(key: String, longitude: Double, latitude: Double, radius: Double, unit: GeoUnit, options: GeoRadiusOptions, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).

Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius). * @param key Key string

longitude: longitude
latitude: latitude
radius: radius
unit: geo unit
options: geo radius options see GeoRadiusOptions
handler: Handler for the result of this call.

def georadiusWithOptionsFuture(key: String, longitude: Double, latitude: Double, radius: Double, unit: GeoUnit, options: GeoRadiusOptions): Future[JsonArray]

Like georadiusWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def georadiusbymember(key: String, member: String, radius: Double, unit: GeoUnit, handler: Handler[AsyncResult[JsonArray]]): RedisClient

This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.

This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set. * @param key Key string

member: member
radius: radius
unit: geo unit
handler: Handler for the result of this call.

def georadiusbymemberFuture(key: String, member: String, radius: Double, unit: GeoUnit): Future[JsonArray]

Like georadiusbymember but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def georadiusbymemberWithOptions(key: String, member: String, radius: Double, unit: GeoUnit, options: GeoRadiusOptions, handler: Handler[AsyncResult[JsonArray]]): RedisClient

This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.

This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set. * @param key Key string

member: member
radius: radius
unit: geo unit
options: geo radius options see GeoRadiusOptions
handler: Handler for the result of this call.

def georadiusbymemberWithOptionsFuture(key: String, member: String, radius: Double, unit: GeoUnit, options: GeoRadiusOptions): Future[JsonArray]

Like georadiusbymemberWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def get(key: String, handler: Handler[AsyncResult[Option[String]]]): RedisClient

Get the value of a key * @param key Key string

handler: Handler for the result of this call.

def getBinary(key: String, handler: Handler[AsyncResult[Option[Buffer]]]): RedisClient

Get the value of a key - without decoding as utf-8 * @param key Key string

handler: Handler for the result of this call.

def getBinaryFuture(key: String): Future[Option[Buffer]]

Like getBinary but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

final def getClass(): Class[_]

Definition Classes: AnyRef → Any
Annotations: @native()

def getFuture(key: String): Future[Option[String]]

Like get but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def getbit(key: String, offset: Long, handler: Handler[AsyncResult[Long]]): RedisClient

Returns the bit value at offset in the string value stored at key * @param key Key string

offset: Offset in bits
handler: Handler for the result of this call.

def getbitFuture(key: String, offset: Long): Future[Long]

Like getbit but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def getrange(key: String, start: Long, end: Long, handler: Handler[AsyncResult[String]]): RedisClient

Get a substring of the string stored at a key * @param key Key string

start: Start offset
end: End offset - inclusive
handler: Handler for the result of this call.

def getrangeFuture(key: String, start: Long, end: Long): Future[String]

Like getrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def getset(key: String, value: String, handler: Handler[AsyncResult[Option[String]]]): RedisClient

Set the string value of a key and return its old value * @param key Key of which value to set

value: New value for the key
handler: Handler for the result of this call.

def getsetFuture(key: String, value: String): Future[Option[String]]

Like getset but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def hashCode(): Int

Definition Classes: AnyRef → Any
Annotations: @native()

def hdel(key: String, field: String, handler: Handler[AsyncResult[Long]]): RedisClient

Delete one or more hash fields * @param key Key string

field: Field name
handler: Handler for the result of this call.

def hdelFuture(key: String, field: String): Future[Long]

Like hdel but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def hdelMany(key: String, fields: Buffer[String], handler: Handler[AsyncResult[Long]]): RedisClient

Delete one or more hash fields * @param key Key string

fields: Field names
handler: Handler for the result of this call.

def hdelManyFuture(key: String, fields: Buffer[String]): Future[Long]

Like hdelMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def hexists(key: String, field: String, handler: Handler[AsyncResult[Long]]): RedisClient

Determine if a hash field exists * @param key Key string

field: Field name
handler: Handler for the result of this call.

def hexistsFuture(key: String, field: String): Future[Long]

Like hexists but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def hget(key: String, field: String, handler: Handler[AsyncResult[Option[String]]]): RedisClient

Get the value of a hash field * @param key Key string

field: Field name
handler: Handler for the result of this call.

def hgetFuture(key: String, field: String): Future[Option[String]]

Like hget but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def hgetall(key: String, handler: Handler[AsyncResult[JsonObject]]): RedisClient

Get all the fields and values in a hash * @param key Key string

handler: Handler for the result of this call.

def hgetallFuture(key: String): Future[JsonObject]

Like hgetall but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def hincrby(key: String, field: String, increment: Long, handler: Handler[AsyncResult[Long]]): RedisClient

Increment the integer value of a hash field by the given number * @param key Key string

field: Field name
increment: Value by which to increment
handler: Handler for the result of this call.

def hincrbyFuture(key: String, field: String, increment: Long): Future[Long]

Like hincrby but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def hincrbyfloat(key: String, field: String, increment: Double, handler: Handler[AsyncResult[String]]): RedisClient

Increment the float value of a hash field by the given amount * @param key Key string

field: Field name
increment: Value by which to increment
handler: Handler for the result of this call.

def hincrbyfloatFuture(key: String, field: String, increment: Double): Future[String]

Like hincrbyfloat but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def hkeys(key: String, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Get all the fields in a hash * @param key Key string

handler: Handler for the result of this call.

def hkeysFuture(key: String): Future[JsonArray]

Like hkeys but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def hlen(key: String, handler: Handler[AsyncResult[Long]]): RedisClient

Get the number of fields in a hash * @param key Key string

handler: Handler for the result of this call.

def hlenFuture(key: String): Future[Long]

Like hlen but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def hmget(key: String, fields: Buffer[String], handler: Handler[AsyncResult[JsonArray]]): RedisClient

Get the values of all the given hash fields * @param key Key string

fields: Field names
handler: Handler for the result of this call.

def hmgetFuture(key: String, fields: Buffer[String]): Future[JsonArray]

Like hmget but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def hmset(key: String, values: JsonObject, handler: Handler[AsyncResult[String]]): RedisClient

Set multiple hash fields to multiple values * @param key Key string

values: Map of field:value pairs
handler: Handler for the result of this call.

def hmsetFuture(key: String, values: JsonObject): Future[String]

Like hmset but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def hscan(key: String, cursor: String, options: ScanOptions, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Incrementally iterate hash fields and associated values * @param key Key string

cursor: Cursor id
options: Scan options see ScanOptions
handler: Handler for the result of this call.

def hscanFuture(key: String, cursor: String, options: ScanOptions): Future[JsonArray]

Like hscan but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def hset(key: String, field: String, value: String, handler: Handler[AsyncResult[Long]]): RedisClient

Set the string value of a hash field * @param key Key string

field: Field name
value: New value
handler: Handler for the result of this call.

def hsetFuture(key: String, field: String, value: String): Future[Long]

Like hset but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def hsetnx(key: String, field: String, value: String, handler: Handler[AsyncResult[Long]]): RedisClient

Set the value of a hash field, only if the field does not exist * @param key Key string

field: Field name
value: New value
handler: Handler for the result of this call.

def hsetnxFuture(key: String, field: String, value: String): Future[Long]

Like hsetnx but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def hstrlen(key: String, field: String, handler: Handler[AsyncResult[Long]]): RedisClient

Get the length of the value of a hash field.

Get the length of the value of a hash field. * @param key Key String

field: field

def hstrlenFuture(key: String, field: String): Future[Long]

Like hstrlen but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def hvals(key: String, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Get all the values in a hash * @param key Key string

handler: Handler for the result of this call.

def hvalsFuture(key: String): Future[JsonArray]

Like hvals but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def incr(key: String, handler: Handler[AsyncResult[Long]]): RedisClient

Increment the integer value of a key by one * @param key Key string

handler: Handler for the result of this call.

def incrFuture(key: String): Future[Long]

Like incr but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def incrby(key: String, increment: Long, handler: Handler[AsyncResult[Long]]): RedisClient

Increment the integer value of a key by the given amount * @param key Key string

increment: Value by which to increment
handler: Handler for the result of this call.

def incrbyFuture(key: String, increment: Long): Future[Long]

Like incrby but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def incrbyfloat(key: String, increment: Double, handler: Handler[AsyncResult[String]]): RedisClient

Increment the float value of a key by the given amount * @param key Key string

increment: Value by which to increment
handler: Handler for the result of this call.

def incrbyfloatFuture(key: String, increment: Double): Future[String]

Like incrbyfloat but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def info(handler: Handler[AsyncResult[JsonObject]]): RedisClient

Get information and statistics about the server * @param handler Handler for the result of this call.

def infoFuture(): Future[JsonObject]

Like info but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def infoSection(section: String, handler: Handler[AsyncResult[JsonObject]]): RedisClient

Get information and statistics about the server * @param section Specific section of information to return

handler: Handler for the result of this call.

def infoSectionFuture(section: String): Future[JsonObject]

Like infoSection but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

def keys(pattern: String, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Find all keys matching the given pattern * @param pattern Pattern to limit the keys returned

handler: Handler for the result of this call.

def keysFuture(pattern: String): Future[JsonArray]

Like keys but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def lastsave(handler: Handler[AsyncResult[Long]]): RedisClient

Get the UNIX time stamp of the last successful save to disk

def lastsaveFuture(): Future[Long]

Like lastsave but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def lindex(key: String, index: Int, handler: Handler[AsyncResult[String]]): RedisClient

Get an element from a list by its index * @param key Key string

index: Index of list element to get
handler: Handler for the result of this call.

def lindexFuture(key: String, index: Int): Future[String]

Like lindex but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def linsert(key: String, option: InsertOptions, pivot: String, value: String, handler: Handler[AsyncResult[Long]]): RedisClient

Insert an element before or after another element in a list * @param key Key string

option: BEFORE or AFTER
pivot: Key to use as a pivot
value: Value to be inserted before or after the pivot
handler: Handler for the result of this call.

def linsertFuture(key: String, option: InsertOptions, pivot: String, value: String): Future[Long]

Like linsert but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def llen(key: String, handler: Handler[AsyncResult[Long]]): RedisClient

Get the length of a list * @param key String key

handler: Handler for the result of this call.

def llenFuture(key: String): Future[Long]

Like llen but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def lpop(key: String, handler: Handler[AsyncResult[Option[String]]]): RedisClient

Remove and get the first element in a list * @param key String key

handler: Handler for the result of this call.

def lpopFuture(key: String): Future[Option[String]]

Like lpop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def lpush(key: String, value: String, handler: Handler[AsyncResult[Long]]): RedisClient

Prepend one value to a list * @param key Key string

value: Value to be added at the beginning of the list
handler: Handler for the result of this call.

def lpushFuture(key: String, value: String): Future[Long]

Like lpush but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def lpushMany(key: String, values: Buffer[String], handler: Handler[AsyncResult[Long]]): RedisClient

Prepend one or multiple values to a list * @param key Key string

values: Values to be added at the beginning of the list, one by one
handler: Handler for the result of this call.

def lpushManyFuture(key: String, values: Buffer[String]): Future[Long]

Like lpushMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def lpushx(key: String, value: String, handler: Handler[AsyncResult[Long]]): RedisClient

Prepend a value to a list, only if the list exists * @param key Key string

value: Value to add at the beginning of the list
handler: Handler for the result of this call.

def lpushxFuture(key: String, value: String): Future[Long]

Like lpushx but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def lrange(key: String, from: Long, to: Long, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Get a range of elements from a list * @param key Key string

from: Start index
to: Stop index
handler: Handler for the result of this call.

def lrangeFuture(key: String, from: Long, to: Long): Future[JsonArray]

Like lrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def lrem(key: String, count: Long, value: String, handler: Handler[AsyncResult[Long]]): RedisClient

Remove elements from a list * @param key Key string

count: Number of first found occurrences equal to $value to remove from the list
value: Value to be removed
handler: Handler for the result of this call.

def lremFuture(key: String, count: Long, value: String): Future[Long]

Like lrem but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def lset(key: String, index: Long, value: String, handler: Handler[AsyncResult[String]]): RedisClient

Set the value of an element in a list by its index * @param key Key string

index: Position within list
value: New value
handler: Handler for the result of this call.

def lsetFuture(key: String, index: Long, value: String): Future[String]

Like lset but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def ltrim(key: String, from: Long, to: Long, handler: Handler[AsyncResult[String]]): RedisClient

Trim a list to the specified range * @param key Key string

from: Start index
to: Stop index
handler: Handler for the result of this call.

def ltrimFuture(key: String, from: Long, to: Long): Future[String]

Like ltrim but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def mget(key: String, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Get the value of the given key * @param key Key string

handler: Handler for the result of this call.

def mgetFuture(key: String): Future[JsonArray]

Like mget but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def mgetMany(keys: Buffer[String], handler: Handler[AsyncResult[JsonArray]]): RedisClient

Get the values of all the given keys * @param keys List of keys to get

handler: Handler for the result of this call.

def mgetManyFuture(keys: Buffer[String]): Future[JsonArray]

Like mgetMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def migrate(host: String, port: Int, key: String, destdb: Int, timeout: Long, options: MigrateOptions, handler: Handler[AsyncResult[String]]): RedisClient

Atomically transfer a key from a Redis instance to another one.

Atomically transfer a key from a Redis instance to another one. * @param host Destination host

port: Destination port
key: Key to migrate
destdb: Destination database index
options: Migrate options see MigrateOptions
handler: Handler for the result of this call.

def migrateFuture(host: String, port: Int, key: String, destdb: Int, timeout: Long, options: MigrateOptions): Future[String]

Like migrate but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def monitor(handler: Handler[AsyncResult[Unit]]): RedisClient

Listen for all requests received by the server in real time

def monitorFuture(): Future[Unit]

Like monitor but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def move(key: String, destdb: Int, handler: Handler[AsyncResult[Long]]): RedisClient

Move a key to another database * @param key Key to migrate

destdb: Destination database index
handler: Handler for the result of this call.

def moveFuture(key: String, destdb: Int): Future[Long]

Like move but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def mset(keyvals: JsonObject, handler: Handler[AsyncResult[String]]): RedisClient

Set multiple keys to multiple values * @param keyvals Key value pairs to set

handler: Handler for the result of this call.

def msetFuture(keyvals: JsonObject): Future[String]

Like mset but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def msetnx(keyvals: JsonObject, handler: Handler[AsyncResult[Long]]): RedisClient

Set multiple keys to multiple values, only if none of the keys exist * @param keyvals Key value pairs to set

handler: Handler for the result of this call.

def msetnxFuture(keyvals: JsonObject): Future[Long]

Like msetnx but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

final def ne(arg0: AnyRef): Boolean

Definition Classes: AnyRef

final def notify(): Unit

Definition Classes: AnyRef
Annotations: @native()

final def notifyAll(): Unit

Definition Classes: AnyRef
Annotations: @native()

def object(key: String, cmd: ObjectCmd, handler: Handler[AsyncResult[Unit]]): RedisClient

Inspect the internals of Redis objects * @param key Key string

cmd: Object sub command
handler: Handler for the result of this call.

def objectFuture(key: String, cmd: ObjectCmd): Future[Unit]

Like object but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def persist(key: String, handler: Handler[AsyncResult[Long]]): RedisClient

Remove the expiration from a key * @param key Key string

handler: Handler for the result of this call.

def persistFuture(key: String): Future[Long]

Like persist but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def pexpire(key: String, millis: Long, handler: Handler[AsyncResult[Long]]): RedisClient

Set a key's time to live in milliseconds * @param key String key

millis: Time to live in milliseconds
handler: Handler for the result of this call.

def pexpireFuture(key: String, millis: Long): Future[Long]

Like pexpire but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def pexpireat(key: String, millis: Long, handler: Handler[AsyncResult[Long]]): RedisClient

Set the expiration for a key as a UNIX timestamp specified in milliseconds * @param key Key string

millis: Expiry time as Unix timestamp in milliseconds
handler: Handler for the result of this call.

def pexpireatFuture(key: String, millis: Long): Future[Long]

Like pexpireat but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def pfadd(key: String, element: String, handler: Handler[AsyncResult[Long]]): RedisClient

Adds the specified element to the specified HyperLogLog.

Adds the specified element to the specified HyperLogLog. * @param key Key string

element: Element to add
handler: Handler for the result of this call.

def pfaddFuture(key: String, element: String): Future[Long]

Like pfadd but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def pfaddMany(key: String, elements: Buffer[String], handler: Handler[AsyncResult[Long]]): RedisClient

Adds the specified elements to the specified HyperLogLog.

Adds the specified elements to the specified HyperLogLog. * @param key Key string

elements: Elementa to add
handler: Handler for the result of this call.

def pfaddManyFuture(key: String, elements: Buffer[String]): Future[Long]

Like pfaddMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def pfcount(key: String, handler: Handler[AsyncResult[Long]]): RedisClient

Return the approximated cardinality of the set observed by the HyperLogLog at key.

Return the approximated cardinality of the set observed by the HyperLogLog at key. * @param key Key string

handler: Handler for the result of this call.

def pfcountFuture(key: String): Future[Long]

Like pfcount but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def pfcountMany(keys: Buffer[String], handler: Handler[AsyncResult[Long]]): RedisClient

Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).

Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s). * @param keys List of keys

handler: Handler for the result of this call.

def pfcountManyFuture(keys: Buffer[String]): Future[Long]

Like pfcountMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def pfmerge(destkey: String, keys: Buffer[String], handler: Handler[AsyncResult[String]]): RedisClient

Merge N different HyperLogLogs into a single one.

Merge N different HyperLogLogs into a single one. * @param destkey Destination key

keys: List of source keys
handler: Handler for the result of this call.

def pfmergeFuture(destkey: String, keys: Buffer[String]): Future[String]

Like pfmerge but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def ping(handler: Handler[AsyncResult[String]]): RedisClient

Ping the server

def pingFuture(): Future[String]

Like ping but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def psetex(key: String, millis: Long, value: String, handler: Handler[AsyncResult[Unit]]): RedisClient

Set the value and expiration in milliseconds of a key * @param key Key string

millis: Number of milliseconds until the key expires
value: New value for key
handler: Handler for the result of this call.

def psetexFuture(key: String, millis: Long, value: String): Future[Unit]

Like psetex but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def psubscribe(pattern: String, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Listen for messages published to channels matching the given pattern * @param pattern Pattern string

handler: Handler for the result of this call.

def psubscribeFuture(pattern: String): Future[JsonArray]

Like psubscribe but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def psubscribeMany(patterns: Buffer[String], handler: Handler[AsyncResult[JsonArray]]): RedisClient

Listen for messages published to channels matching the given patterns * @param patterns List of patterns

handler: Handler for the result of this call.

def psubscribeManyFuture(patterns: Buffer[String]): Future[JsonArray]

Like psubscribeMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def pttl(key: String, handler: Handler[AsyncResult[Long]]): RedisClient

Get the time to live for a key in milliseconds * @param key Key string

handler: Handler for the result of this call.

def pttlFuture(key: String): Future[Long]

Like pttl but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def publish(channel: String, message: String, handler: Handler[AsyncResult[Long]]): RedisClient

Post a message to a channel * @param channel Channel key

message: Message to send to channel
handler: Handler for the result of this call.

def publishFuture(channel: String, message: String): Future[Long]

Like publish but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def pubsubChannels(pattern: String, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Lists the currently active channels - only those matching the pattern * @param pattern A glob-style pattern - an empty string means no pattern

handler: Handler for the result of this call.

def pubsubChannelsFuture(pattern: String): Future[JsonArray]

Like pubsubChannels but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def pubsubNumpat(handler: Handler[AsyncResult[Long]]): RedisClient

Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command) * @param handler Handler for the result of this call.

def pubsubNumpatFuture(): Future[Long]

Like pubsubNumpat but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def pubsubNumsub(channels: Buffer[String], handler: Handler[AsyncResult[JsonArray]]): RedisClient

Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels * @param channels List of channels

handler: Handler for the result of this call.

def pubsubNumsubFuture(channels: Buffer[String]): Future[JsonArray]

Like pubsubNumsub but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def punsubscribe(patterns: Buffer[String], handler: Handler[AsyncResult[Unit]]): RedisClient

Stop listening for messages posted to channels matching the given patterns * @param patterns List of patterns to match against

handler: Handler for the result of this call.

def punsubscribeFuture(patterns: Buffer[String]): Future[Unit]

Like punsubscribe but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def randomkey(handler: Handler[AsyncResult[String]]): RedisClient

Return a random key from the keyspace

def randomkeyFuture(): Future[String]

Like randomkey but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def rename(key: String, newkey: String, handler: Handler[AsyncResult[String]]): RedisClient

Rename a key * @param key Key string to be renamed

newkey: New key string
handler: Handler for the result of this call.

def renameFuture(key: String, newkey: String): Future[String]

Like rename but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def renamenx(key: String, newkey: String, handler: Handler[AsyncResult[Long]]): RedisClient

Rename a key, only if the new key does not exist * @param key Key string to be renamed

newkey: New key string
handler: Handler for the result of this call.

def renamenxFuture(key: String, newkey: String): Future[Long]

Like renamenx but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def restore(key: String, millis: Long, serialized: String, handler: Handler[AsyncResult[String]]): RedisClient

Create a key using the provided serialized value, previously obtained using DUMP.

Create a key using the provided serialized value, previously obtained using DUMP. * @param key Key string

millis: Expiry time in milliseconds to set on the key
serialized: Serialized form of the key value as obtained using DUMP
handler: Handler for the result of this call.

def restoreFuture(key: String, millis: Long, serialized: String): Future[String]

Like restore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def role(handler: Handler[AsyncResult[JsonArray]]): RedisClient

Return the role of the instance in the context of replication

def roleFuture(): Future[JsonArray]

Like role but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def rpop(key: String, handler: Handler[AsyncResult[String]]): RedisClient

Remove and get the last element in a list * @param key Key string

handler: Handler for the result of this call.

def rpopFuture(key: String): Future[String]

Like rpop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def rpoplpush(key: String, destkey: String, handler: Handler[AsyncResult[String]]): RedisClient

Remove the last element in a list, append it to another list and return it * @param key Key string identifying source list

destkey: Key string identifying destination list
handler: Handler for the result of this call.

def rpoplpushFuture(key: String, destkey: String): Future[String]

Like rpoplpush but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def rpush(key: String, value: String, handler: Handler[AsyncResult[Long]]): RedisClient

Append one or multiple values to a list * @param key Key string

value: Value to be added to the end of the list
handler: Handler for the result of this call.

def rpushFuture(key: String, value: String): Future[Long]

Like rpush but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def rpushMany(key: String, values: Buffer[String], handler: Handler[AsyncResult[Long]]): RedisClient

Append one or multiple values to a list * @param key Key string

values: List of values to add to the end of the list
handler: Handler for the result of this call.

def rpushManyFuture(key: String, values: Buffer[String]): Future[Long]

Like rpushMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def rpushx(key: String, value: String, handler: Handler[AsyncResult[Long]]): RedisClient

Append a value to a list, only if the list exists * @param key Key string

value: Value to be added to the end of the list
handler: Handler for the result of this call.

def rpushxFuture(key: String, value: String): Future[Long]

Like rpushx but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def sadd(key: String, member: String, handler: Handler[AsyncResult[Long]]): RedisClient

Add a member to a set * @param key Key string

member: Value to be added to the set
handler: Handler for the result of this call.

def saddFuture(key: String, member: String): Future[Long]

Like sadd but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def saddMany(key: String, members: Buffer[String], handler: Handler[AsyncResult[Long]]): RedisClient

Add one or more members to a set * @param key Key string

members: Values to be added to the set
handler: Handler for the result of this call.

def saddManyFuture(key: String, members: Buffer[String]): Future[Long]

Like saddMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def save(handler: Handler[AsyncResult[String]]): RedisClient

Synchronously save the dataset to disk

def saveFuture(): Future[String]

Like save but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def scan(cursor: String, options: ScanOptions, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Incrementally iterate the keys space * @param cursor Cursor id

options: Scan options see ScanOptions
handler: Handler for the result of this call.

def scanFuture(cursor: String, options: ScanOptions): Future[JsonArray]

Like scan but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def scard(key: String, handler: Handler[AsyncResult[Long]]): RedisClient

Get the number of members in a set * @param key Key string

handler: Handler for the result of this call.

def scardFuture(key: String): Future[Long]

Like scard but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def scriptDebug(scriptDebugOptions: ScriptDebugOptions, handler: Handler[AsyncResult[String]]): RedisClient

Set the debug mode for executed scripts.

Set the debug mode for executed scripts. * @param scriptDebugOptions the option

def scriptDebugFuture(scriptDebugOptions: ScriptDebugOptions): Future[String]

Like scriptDebug but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def scriptExists(script: String, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Check existence of script in the script cache.

Check existence of script in the script cache. * @param script SHA1 digest identifying a script in the script cache

handler: Handler for the result of this call.

def scriptExistsFuture(script: String): Future[JsonArray]

Like scriptExists but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def scriptExistsMany(scripts: Buffer[String], handler: Handler[AsyncResult[JsonArray]]): RedisClient

Check existence of scripts in the script cache.

Check existence of scripts in the script cache. * @param scripts List of SHA1 digests identifying scripts in the script cache

handler: Handler for the result of this call.

def scriptExistsManyFuture(scripts: Buffer[String]): Future[JsonArray]

Like scriptExistsMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def scriptFlush(handler: Handler[AsyncResult[String]]): RedisClient

Remove all the scripts from the script cache.

def scriptFlushFuture(): Future[String]

Like scriptFlush but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def scriptKill(handler: Handler[AsyncResult[String]]): RedisClient

Kill the script currently in execution.

def scriptKillFuture(): Future[String]

Like scriptKill but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def scriptLoad(script: String, handler: Handler[AsyncResult[String]]): RedisClient

Load the specified Lua script into the script cache.

Load the specified Lua script into the script cache. * @param script Lua script

handler: Handler for the result of this call.

def scriptLoadFuture(script: String): Future[String]

Like scriptLoad but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def sdiff(key: String, cmpkeys: Buffer[String], handler: Handler[AsyncResult[JsonArray]]): RedisClient

Subtract multiple sets * @param key Key identifying the set to compare with all other sets combined

cmpkeys: List of keys identifying sets to subtract from the key set
handler: Handler for the result of this call.

def sdiffFuture(key: String, cmpkeys: Buffer[String]): Future[JsonArray]

Like sdiff but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def sdiffstore(destkey: String, key: String, cmpkeys: Buffer[String], handler: Handler[AsyncResult[Long]]): RedisClient

Subtract multiple sets and store the resulting set in a key * @param destkey Destination key where the result should be stored

key: Key identifying the set to compare with all other sets combined
cmpkeys: List of keys identifying sets to subtract from the key set
handler: Handler for the result of this call.

def sdiffstoreFuture(destkey: String, key: String, cmpkeys: Buffer[String]): Future[Long]

Like sdiffstore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def select(dbindex: Int, handler: Handler[AsyncResult[String]]): RedisClient

Change the selected database for the current connection * @param dbindex Index identifying the new active database

handler: Handler for the result of this call.

def selectFuture(dbindex: Int): Future[String]

Like select but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def set(key: String, value: String, handler: Handler[AsyncResult[Unit]]): RedisClient

Set the string value of a key * @param key Key of which value to set

value: New value for the key
handler: Handler for the result of this call.

def setBinary(key: String, value: Buffer, handler: Handler[AsyncResult[Unit]]): RedisClient

Set the binary string value of a key - without encoding as utf-8 * @param key Key of which value to set

value: New value for the key
handler: Handler for the result of this call.

def setBinaryFuture(key: String, value: Buffer): Future[Unit]

Like setBinary but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def setBinaryWithOptions(key: String, value: Buffer, options: SetOptions, handler: Handler[AsyncResult[Unit]]): RedisClient

Set the string value of a key * @param key Key of which value to set

value: New value for the key
options: Set options see SetOptions
handler: Handler for the result of this call.

def setBinaryWithOptionsFuture(key: String, value: Buffer, options: SetOptions): Future[Unit]

Like setBinaryWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def setFuture(key: String, value: String): Future[Unit]

Like set but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def setWithOptions(key: String, value: String, options: SetOptions, handler: Handler[AsyncResult[String]]): RedisClient

Set the string value of a key * @param key Key of which value to set

value: New value for the key
options: Set options see SetOptions
handler: Handler for the result of this call.

def setWithOptionsFuture(key: String, value: String, options: SetOptions): Future[String]

Like setWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def setbit(key: String, offset: Long, bit: Int, handler: Handler[AsyncResult[Long]]): RedisClient

Sets or clears the bit at offset in the string value stored at key * @param key Key string

offset: Bit offset
bit: New value - must be 1 or 0
handler: Handler for the result of this call.

def setbitFuture(key: String, offset: Long, bit: Int): Future[Long]

Like setbit but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def setex(key: String, seconds: Long, value: String, handler: Handler[AsyncResult[String]]): RedisClient

Set the value and expiration of a key * @param key Key string

seconds: Number of seconds until the key expires
value: New value for key
handler: Handler for the result of this call.

def setexFuture(key: String, seconds: Long, value: String): Future[String]

Like setex but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def setnx(key: String, value: String, handler: Handler[AsyncResult[Long]]): RedisClient

Set the value of a key, only if the key does not exist * @param key Key of which value to set

value: New value for the key
handler: Handler for the result of this call.

def setnxFuture(key: String, value: String): Future[Long]

Like setnx but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def setrange(key: String, offset: Int, value: String, handler: Handler[AsyncResult[Long]]): RedisClient

Overwrite part of a string at key starting at the specified offset * @param key Key string

offset: Offset - the maximum offset that you can set is 2^29 -1 (536870911), as Redis Strings are limited to 512 megabytes
value: Value to overwrite with
handler: Handler for the result of this call.

def setrangeFuture(key: String, offset: Int, value: String): Future[Long]

Like setrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def sinter(keys: Buffer[String], handler: Handler[AsyncResult[JsonArray]]): RedisClient

Intersect multiple sets * @param keys List of keys to perform intersection on

handler: Handler for the result of this call.

def sinterFuture(keys: Buffer[String]): Future[JsonArray]

Like sinter but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def sinterstore(destkey: String, keys: Buffer[String], handler: Handler[AsyncResult[Long]]): RedisClient

Intersect multiple sets and store the resulting set in a key * @param destkey Key where to store the results

keys: List of keys to perform intersection on
handler: Handler for the result of this call.

def sinterstoreFuture(destkey: String, keys: Buffer[String]): Future[Long]

Like sinterstore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def sismember(key: String, member: String, handler: Handler[AsyncResult[Long]]): RedisClient

Determine if a given value is a member of a set * @param key Key string

member: Member to look for
handler: Handler for the result of this call.

def sismemberFuture(key: String, member: String): Future[Long]

Like sismember but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def slaveof(host: String, port: Int, handler: Handler[AsyncResult[String]]): RedisClient

Make the server a slave of another instance * @param host Host to become this server's master

port: Port of our new master
handler: Handler for the result of this call.

def slaveofFuture(host: String, port: Int): Future[String]

Like slaveof but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def slaveofNoone(handler: Handler[AsyncResult[String]]): RedisClient

Make this server a master * @param handler Handler for the result of this call.

def slaveofNooneFuture(): Future[String]

Like slaveofNoone but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def slowlogGet(limit: Int, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Read the Redis slow queries log * @param limit Number of log entries to return.

Read the Redis slow queries log * @param limit Number of log entries to return. If value is less than zero all entries are returned

handler: Handler for the result of this call.

def slowlogGetFuture(limit: Int): Future[JsonArray]

Like slowlogGet but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def slowlogLen(handler: Handler[AsyncResult[Long]]): RedisClient

Get the length of the Redis slow queries log * @param handler Handler for the result of this call.

def slowlogLenFuture(): Future[Long]

Like slowlogLen but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def slowlogReset(handler: Handler[AsyncResult[Unit]]): RedisClient

Reset the Redis slow queries log * @param handler Handler for the result of this call.

def slowlogResetFuture(): Future[Unit]

Like slowlogReset but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def smembers(key: String, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Get all the members in a set * @param key Key string

handler: Handler for the result of this call.

def smembersFuture(key: String): Future[JsonArray]

Like smembers but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def smove(key: String, destkey: String, member: String, handler: Handler[AsyncResult[Long]]): RedisClient

Move a member from one set to another * @param key Key of source set currently containing the member

destkey: Key identifying the destination set
member: Member to move
handler: Handler for the result of this call.

def smoveFuture(key: String, destkey: String, member: String): Future[Long]

Like smove but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def sort(key: String, options: SortOptions, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Sort the elements in a list, set or sorted set * @param key Key string

options: Sort options see SortOptions
handler: Handler for the result of this call.

def sortFuture(key: String, options: SortOptions): Future[JsonArray]

Like sort but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def spop(key: String, handler: Handler[AsyncResult[Option[String]]]): RedisClient

Remove and return a random member from a set * @param key Key string

handler: Handler for the result of this call.

def spopFuture(key: String): Future[Option[String]]

Like spop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def spopMany(key: String, count: Int, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Remove and return random members from a set * @param key Key string

count: Number of members to remove
handler: Handler for the result of this call.

def spopManyFuture(key: String, count: Int): Future[JsonArray]

Like spopMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def srandmember(key: String, handler: Handler[AsyncResult[String]]): RedisClient

Get one or multiple random members from a set * @param key Key string

handler: Handler for the result of this call.

def srandmemberCount(key: String, count: Int, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Get one or multiple random members from a set * @param key Key string

count: Number of members to get
handler: Handler for the result of this call.

def srandmemberCountFuture(key: String, count: Int): Future[JsonArray]

Like srandmemberCount but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def srandmemberFuture(key: String): Future[String]

Like srandmember but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def srem(key: String, member: String, handler: Handler[AsyncResult[Long]]): RedisClient

Remove one member from a set * @param key Key string

member: Member to remove
handler: Handler for the result of this call.

def sremFuture(key: String, member: String): Future[Long]

Like srem but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def sremMany(key: String, members: Buffer[String], handler: Handler[AsyncResult[Long]]): RedisClient

Remove one or more members from a set * @param key Key string

members: Members to remove
handler: Handler for the result of this call.

def sremManyFuture(key: String, members: Buffer[String]): Future[Long]

Like sremMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def sscan(key: String, cursor: String, options: ScanOptions, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Incrementally iterate Set elements * @param key Key string

cursor: Cursor id
options: Scan options see ScanOptions
handler: Handler for the result of this call.

def sscanFuture(key: String, cursor: String, options: ScanOptions): Future[JsonArray]

Like sscan but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def strlen(key: String, handler: Handler[AsyncResult[Long]]): RedisClient

Get the length of the value stored in a key * @param key Key string

handler: Handler for the result of this call.

def strlenFuture(key: String): Future[Long]

Like strlen but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def subscribe(channel: String, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Listen for messages published to the given channels * @param channel Channel to subscribe to

handler: Handler for the result of this call.

def subscribeFuture(channel: String): Future[JsonArray]

Like subscribe but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def subscribeMany(channels: Buffer[String], handler: Handler[AsyncResult[JsonArray]]): RedisClient

Listen for messages published to the given channels * @param channels List of channels to subscribe to

handler: Handler for the result of this call.

def subscribeManyFuture(channels: Buffer[String]): Future[JsonArray]

Like subscribeMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def sunion(keys: Buffer[String], handler: Handler[AsyncResult[JsonArray]]): RedisClient

Add multiple sets * @param keys List of keys identifying sets to add up

handler: Handler for the result of this call.

def sunionFuture(keys: Buffer[String]): Future[JsonArray]

Like sunion but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def sunionstore(destkey: String, keys: Buffer[String], handler: Handler[AsyncResult[Long]]): RedisClient

Add multiple sets and store the resulting set in a key * @param destkey Destination key

keys: List of keys identifying sets to add up
handler: Handler for the result of this call.

def sunionstoreFuture(destkey: String, keys: Buffer[String]): Future[Long]

Like sunionstore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def swapdb(index1: Int, index2: Int, handler: Handler[AsyncResult[String]]): RedisClient

Swaps two Redis databases * @param index1 index of first database to swap

index2: index of second database to swap
handler: Handler for the result of this call.

def swapdbFuture(index1: Int, index2: Int): Future[String]

Like swapdb but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def sync(handler: Handler[AsyncResult[Unit]]): RedisClient

Internal command used for replication

def syncFuture(): Future[Unit]

Like sync but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

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

Definition Classes: AnyRef

def time(handler: Handler[AsyncResult[JsonArray]]): RedisClient

Return the current server time

def timeFuture(): Future[JsonArray]

Like time but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def toString(): String

Definition Classes: AnyRef → Any

def touch(key: String, handler: Handler[AsyncResult[Long]]): RedisClient

Alters the last access time of a key(s).

Alters the last access time of a key(s). Returns the number of existing keys specified. * @param key Key String

def touchFuture(key: String): Future[Long]

Like touch but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def touchMany(keys: Buffer[String], handler: Handler[AsyncResult[Long]]): RedisClient

Alters the last access time of a key(s).

Alters the last access time of a key(s). Returns the number of existing keys specified. * @param keys list of keys

def touchManyFuture(keys: Buffer[String]): Future[Long]

Like touchMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def transaction(): RedisTransaction

Return a RedisTransaction instance * @return transaction instance

def ttl(key: String, handler: Handler[AsyncResult[Long]]): RedisClient

Get the time to live for a key * @param key Key string

handler: Handler for the result of this call.

def ttlFuture(key: String): Future[Long]

Like ttl but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def type(key: String, handler: Handler[AsyncResult[String]]): RedisClient

Determine the type stored at key * @param key Key string

handler: Handler for the result of this call.

def typeFuture(key: String): Future[String]

Like type but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def unlink(key: String, handler: Handler[AsyncResult[Long]]): RedisClient

Delete a key asynchronously in another thread.

Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking. * @param key Key to delete

handler: Handler for the result of this call.

def unlinkFuture(key: String): Future[Long]

Like unlink but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def unlinkMany(keys: Buffer[String], handler: Handler[AsyncResult[Long]]): RedisClient

Delete multiple keys asynchronously in another thread.

Delete multiple keys asynchronously in another thread. Otherwise it is just as DEL, but non blocking. * @param keys List of keys to delete

handler: Handler for the result of this call.

def unlinkManyFuture(keys: Buffer[String]): Future[Long]

Like unlinkMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def unsubscribe(channels: Buffer[String], handler: Handler[AsyncResult[Unit]]): RedisClient

Stop listening for messages posted to the given channels * @param channels List of channels to subscribe to

handler: Handler for the result of this call.

def unsubscribeFuture(channels: Buffer[String]): Future[Unit]

Like unsubscribe but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def wait(numSlaves: Long, timeout: Long, handler: Handler[AsyncResult[String]]): RedisClient

Wait for the synchronous replication of all the write commands sent in the context of the current connection.

Wait for the synchronous replication of all the write commands sent in the context of the current connection. * @param handler Handler for the result of this call.

final def wait(): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

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

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long): Unit

Definition Classes: AnyRef
Annotations: @native() @throws( ... )

def waitFuture(numSlaves: Long, timeout: Long): Future[String]

Like wait but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zadd(key: String, score: Double, member: String, handler: Handler[AsyncResult[Long]]): RedisClient

Add one or more members to a sorted set, or update its score if it already exists * @param key Key string

score: Score used for sorting
member: New member key
handler: Handler for the result of this call.

def zaddFuture(key: String, score: Double, member: String): Future[Long]

Like zadd but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zaddMany(key: String, members: Map[String, Double], handler: Handler[AsyncResult[Long]]): RedisClient

Add one or more members to a sorted set, or update its score if it already exists * @param key Key string

members: New member keys and their scores
handler: Handler for the result of this call.

def zaddManyFuture(key: String, members: Map[String, Double]): Future[Long]

Like zaddMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zcard(key: String, handler: Handler[AsyncResult[Long]]): RedisClient

Get the number of members in a sorted set * @param key Key string

handler: Handler for the result of this call.

def zcardFuture(key: String): Future[Long]

Like zcard but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zcount(key: String, min: Double, max: Double, handler: Handler[AsyncResult[Long]]): RedisClient

Count the members in a sorted set with scores within the given values * @param key Key string

min: Minimum score
max: Maximum score
handler: Handler for the result of this call.

def zcountFuture(key: String, min: Double, max: Double): Future[Long]

Like zcount but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zincrby(key: String, increment: Double, member: String, handler: Handler[AsyncResult[String]]): RedisClient

Increment the score of a member in a sorted set * @param key Key string

increment: Increment amount
member: Member key
handler: Handler for the result of this call.

def zincrbyFuture(key: String, increment: Double, member: String): Future[String]

Like zincrby but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zinterstore(destkey: String, sets: Buffer[String], options: AggregateOptions, handler: Handler[AsyncResult[Long]]): RedisClient

Intersect multiple sorted sets and store the resulting sorted set in a new key * @param destkey Destination key

sets: List of keys identifying sorted sets to intersect
options: Aggregation options
handler: Handler for the result of this call.

def zinterstoreFuture(destkey: String, sets: Buffer[String], options: AggregateOptions): Future[Long]

Like zinterstore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zinterstoreWeighed(destkey: String, sets: Map[String, Double], options: AggregateOptions, handler: Handler[AsyncResult[Long]]): RedisClient

Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring * @param destkey Destination key

sets: List of keys identifying sorted sets to intersect
options: Aggregation options
handler: Handler for the result of this call.

def zinterstoreWeighedFuture(destkey: String, sets: Map[String, Double], options: AggregateOptions): Future[Long]

Like zinterstoreWeighed but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zlexcount(key: String, min: String, max: String, handler: Handler[AsyncResult[Long]]): RedisClient

Count the number of members in a sorted set between a given lexicographical range * @param key Key string

min: Pattern to compare against for minimum value
max: Pattern to compare against for maximum value
handler: Handler for the result of this call.

def zlexcountFuture(key: String, min: String, max: String): Future[Long]

Like zlexcount but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zrange(key: String, start: Long, stop: Long, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Return a range of members in a sorted set, by index * @param key Key string

start: Start index for the range
stop: Stop index for the range - inclusive
handler: Handler for the result of this call.

def zrangeFuture(key: String, start: Long, stop: Long): Future[JsonArray]

Like zrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zrangeWithOptions(key: String, start: Long, stop: Long, options: RangeOptions, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Return a range of members in a sorted set, by index * @param key Key string

start: Start index for the range
stop: Stop index for the range - inclusive
options: Range options
handler: Handler for the result of this call.

def zrangeWithOptionsFuture(key: String, start: Long, stop: Long, options: RangeOptions): Future[JsonArray]

Like zrangeWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zrangebylex(key: String, min: String, max: String, options: LimitOptions, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Return a range of members in a sorted set, by lexicographical range * @param key Key string

min: Pattern representing a minimum allowed value
max: Pattern representing a maximum allowed value
options: Limit options where limit can be specified see LimitOptions
handler: Handler for the result of this call.

def zrangebylexFuture(key: String, min: String, max: String, options: LimitOptions): Future[JsonArray]

Like zrangebylex but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zrangebyscore(key: String, min: String, max: String, options: RangeLimitOptions, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Return a range of members in a sorted set, by score * @param key Key string

min: Pattern defining a minimum value
max: Pattern defining a maximum value
options: Range and limit options see RangeLimitOptions
handler: Handler for the result of this call.

def zrangebyscoreFuture(key: String, min: String, max: String, options: RangeLimitOptions): Future[JsonArray]

Like zrangebyscore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zrank(key: String, member: String, handler: Handler[AsyncResult[Long]]): RedisClient

Determine the index of a member in a sorted set * @param key Key string

member: Member in the sorted set identified by key
handler: Handler for the result of this call.

def zrankFuture(key: String, member: String): Future[Long]

Like zrank but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zrem(key: String, member: String, handler: Handler[AsyncResult[Long]]): RedisClient

Remove one member from a sorted set * @param key Key string

member: Member in the sorted set identified by key
handler: Handler for the result of this call.

def zremFuture(key: String, member: String): Future[Long]

Like zrem but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zremMany(key: String, members: Buffer[String], handler: Handler[AsyncResult[Long]]): RedisClient

Remove one or more members from a sorted set * @param key Key string

members: Members in the sorted set identified by key
handler: Handler for the result of this call.

def zremManyFuture(key: String, members: Buffer[String]): Future[Long]

Like zremMany but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zremrangebylex(key: String, min: String, max: String, handler: Handler[AsyncResult[Long]]): RedisClient

Remove all members in a sorted set between the given lexicographical range * @param key Key string

min: Pattern defining a minimum value
max: Pattern defining a maximum value
handler: Handler for the result of this call.

def zremrangebylexFuture(key: String, min: String, max: String): Future[Long]

Like zremrangebylex but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zremrangebyrank(key: String, start: Long, stop: Long, handler: Handler[AsyncResult[Long]]): RedisClient

Remove all members in a sorted set within the given indexes * @param key Key string

start: Start index
stop: Stop index
handler: Handler for the result of this call.

def zremrangebyrankFuture(key: String, start: Long, stop: Long): Future[Long]

Like zremrangebyrank but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zremrangebyscore(key: String, min: String, max: String, handler: Handler[AsyncResult[Long]]): RedisClient

Remove all members in a sorted set within the given scores * @param key Key string

min: Pattern defining a minimum value
max: Pattern defining a maximum value

def zremrangebyscoreFuture(key: String, min: String, max: String): Future[Long]

Like zremrangebyscore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zrevrange(key: String, start: Long, stop: Long, options: RangeOptions, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Return a range of members in a sorted set, by index, with scores ordered from high to low * @param key Key string

start: Start index for the range
stop: Stop index for the range - inclusive
options: Range options
handler: Handler for the result of this call.

def zrevrangeFuture(key: String, start: Long, stop: Long, options: RangeOptions): Future[JsonArray]

Like zrevrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zrevrangebylex(key: String, max: String, min: String, options: LimitOptions, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low * @param key Key string

max: Pattern defining a maximum value
min: Pattern defining a minimum value
options: Limit options see LimitOptions
handler: Handler for the result of this call.

def zrevrangebylexFuture(key: String, max: String, min: String, options: LimitOptions): Future[JsonArray]

Like zrevrangebylex but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zrevrangebyscore(key: String, max: String, min: String, options: RangeLimitOptions, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Return a range of members in a sorted set, by score, with scores ordered from high to low * @param key Key string

max: Pattern defining a maximum value
min: Pattern defining a minimum value
options: Range and limit options see RangeLimitOptions
handler: Handler for the result of this call.

def zrevrangebyscoreFuture(key: String, max: String, min: String, options: RangeLimitOptions): Future[JsonArray]

Like zrevrangebyscore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zrevrank(key: String, member: String, handler: Handler[AsyncResult[Long]]): RedisClient

Determine the index of a member in a sorted set, with scores ordered from high to low * @param key Key string

member: Member in the sorted set identified by key
handler: Handler for the result of this call.

def zrevrankFuture(key: String, member: String): Future[Long]

Like zrevrank but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zscan(key: String, cursor: String, options: ScanOptions, handler: Handler[AsyncResult[JsonArray]]): RedisClient

Incrementally iterate sorted sets elements and associated scores * @param key Key string

cursor: Cursor id
options: Scan options see ScanOptions
handler: Handler for the result of this call.

def zscanFuture(key: String, cursor: String, options: ScanOptions): Future[JsonArray]

Like zscan but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zscore(key: String, member: String, handler: Handler[AsyncResult[String]]): RedisClient

Get the score associated with the given member in a sorted set * @param key Key string

member: Member in the sorted set identified by key
handler: Handler for the result of this call.

def zscoreFuture(key: String, member: String): Future[String]

Like zscore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zunionstore(destkey: String, sets: Buffer[String], options: AggregateOptions, handler: Handler[AsyncResult[Long]]): RedisClient

Add multiple sorted sets and store the resulting sorted set in a new key * @param destkey Destination key

sets: List of keys identifying sorted sets
options: Aggregation options
handler: Handler for the result of this call.

def zunionstoreFuture(destkey: String, sets: Buffer[String], options: AggregateOptions): Future[Long]

Like zunionstore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def zunionstoreWeighed(key: String, sets: Map[String, Double], options: AggregateOptions, handler: Handler[AsyncResult[Long]]): RedisClient

Add multiple sorted sets using weights, and store the resulting sorted set in a new key * @param key Destination key

sets: Map containing set-key:weight pairs
options: Aggregation options
handler: Handler for the result of this call.

def zunionstoreWeighedFuture(key: String, sets: Map[String, Double], options: AggregateOptions): Future[Long]

Like zunionstoreWeighed but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

Packages

RedisClient

Companion object RedisClient

class RedisClient extends AnyRef

Instance Constructors

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

RedisClient 

Companion object RedisClient

class RedisClient extends AnyRef

Instance Constructors

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

RedisClient