BookSleeve

Represents the state of an individual client connection to redis

Format the object as a string

address/port of the client

total duration of the connection in seconds

idle time of the connection in seconds

current database ID

number of channel subscriptions

number of pattern matching subscriptions

number of commands in a MULTI/EXEC context

The client flags can be a combination of: O: the client is a slave in MONITOR mode S: the client is a normal slave server M: the client is a master x: the client is in a MULTI/EXEC context b: the client is waiting in a blocking operation i: the client is waiting for a VM I/O (deprecated) d: a watched keys has been modified - EXEC will fail c: connection to be closed after writing entire reply u: the client is unblocked A: connection to be closed ASAP N: no specific flag set

The flags associated with this connection

last command played

The name allocated to this connection, if any

no specific flag set

the client is a slave in MONITOR mode

the client is a normal slave server

the client is a master

the client is in a MULTI/EXEC context

the client is waiting in a blocking operation

a watched keys has been modified - EXEC will fail

connection to be closed after writing entire reply

the client is unblocked

connection to be closed ASAP

Represents the information known about long-running commands

Deduces a link to the redis documentation about the specified command

A unique progressive identifier for every slow log entry.

The entry's unique ID can be used in order to avoid processing slow log entries multiple times (for instance you may have a script sending you an email alert for every new slow log entry). The ID is never reset in the course of the Redis server execution, only a server restart will reset it.

The time at which the logged command was processed.

The amount of time needed for its execution

The array composing the arguments of the command.

Describes a pre-condition used in a redis transaction

Enforces that the given key must exist

Enforces that the given key must not exist

Enforces that the given hash-field must exist

Enforces that the given hash-field must not exist

Enforces that the given key must have the specified value

Enforces that the given key must not have the specified value

Enforces that the given hash-field must have the specified value

Enforces that the given hash-field must not have the specified value

Provides utility methods for managing connections to multiple (master/slave) redis servers (with the same information - not sharding).

Inspect the provided configration, and connect to the available servers to report which server is the preferred/active node.

Inspect the provided configration, and connect to the preferred/active node after checking what nodes are available.

Subscribe to perform some operation when a change to the preferred/active node is broadcast.

Using the configuration available, and after checking which nodes are available, switch the master node and broadcast this change.

Prompt all clients to reconnect.

A thread-safe, multiplexed connection to a Redis server; each connection should be cached and re-used (without synchronization) from multiple callers for maximum efficiency. Usually only a single RedisConnection is required

Base class for a redis-connection; provides core redis services

The default time to wait for individual commands to complete when using Wait

Explicitly specify the server version; this is useful when INFO is not available

Obtains fresh statistics on the usage of the connection

Issues a basic ping/pong pair against the server, returning the latency

Releases any resources associated with the connection

Called after opening a connection

Called before opening a connection

Called during connection init, but after the AUTH is sent (if needed)

Whether to release any queued messages

An already-completed task that indicates success

Attempts to open the connection to the remote server

Releases the queue of any messages "sent" before the connection was open

Invoked when we have completed the handshake

Specify a name for the current connection

The INFO command returns information and statistics about the server in format that is simple to parse by computers and easy to red by humans.

http://redis.io/commands/info

The INFO command returns information and statistics about the server in format that is simple to parse by computers and easy to red by humans.

http://redis.io/commands/info

Closes the connection; either draining the unsent queue (to completion), or abandoning the unsent queue.

Peek at the next item in the sent-queue

Invoked when the server is terminating

Indicates the number of commands executed on a per-database basis

Raises an error event

Return the number of items in the sent-queue

Temporarily suspends eager-flushing (flushing if the write-queue becomes empty briefly). Buffer-based flushing will still occur when the data is full. This is useful if you are performing a large number of operations in close duration, and want to avoid packet fragmentation. Note that you MUST call ResumeFlush at the end of the operation - preferably using Try/Finally so that flushing is resumed even upon error. This method is thread-safe; any number of callers can suspend/resume flushing concurrently - eager flushing will resume fully when all callers have called ResumeFlush.

Note that some operations (transaction conditions, etc) require flushing - this will still occur even if the buffer is only part full.

Resume eager-flushing (flushing if the write-queue becomes empty briefly). See SuspendFlush for full usage.

Writes a group of messages, but allowing other threads to inject messages between them; this method minimises the numbers of packets by preventing flush until all are written

The message to supply to callers when rejecting messages

If the task is not yet completed, blocks the caller until completion up to a maximum of SyncTimeout milliseconds. Once a task is completed, the result is returned.

The task to wait on The return value of the task. If SyncTimeout milliseconds is exceeded.

If the task is not yet completed, blocks the caller until completion up to a maximum of SyncTimeout milliseconds.

The task to wait on If SyncTimeout milliseconds is exceeded. If an exception is throw, it is extracted from the AggregateException (unless multiple exceptions are found)

Give some information about the oldest incomplete (but sent) message on the server

Waits for all of a set of tasks to complete, up to a maximum of SyncTimeout milliseconds.

The tasks to wait on If SyncTimeout milliseconds is exceeded.

Waits for any of a set of tasks to complete, up to a maximum of SyncTimeout milliseconds.

The tasks to wait on The index of a completed task If SyncTimeout milliseconds is exceeded.

Add a continuation (a callback), to be executed once a task has completed

The task to add a continuation to The continuation to perform once completed A new task representing the composed operation

Add a continuation (a callback), to be executed once a task has completed

The task to add a continuation to The continuation to perform once completed A new task representing the composed operation

Attempt to reduce Task overhead by completing tasks without continuations synchronously (default is asynchronously)

The amount of time to wait for any individual command to return a result when using Wait

The host for the redis server

The password used to authenticate with the redis server

The port for the redis server

The IO timeout to use when communicating with the redis server

Features available to the redis server

Specify a name for this connection (displayed via Server.ListClients / CLIENT LIST)

The version of the connected redis server

The current state of the connection

Indicate the number of messages that have not yet been set.

Raised when a connection becomes closed.

If the connection has been shut down, what was the reason?

Should a QUIT be sent when closing the connection?

How frequently should keep-alives be sent?

Invoked when the server is shutting down; includes any error information

Invoked when any error message is received on the connection.

If true, then when using the Wait methods, information about the oldest outstanding message is included in the exception; this often points to a particular operation that was monopolising the connection

What type of connection is this

Gets or sets the behavior for processing incoming messages.

Gets or sets the default CompletionMode value for all new connections.

Indicates the current state of the connection to the server

A connection that has not yet been innitialized

A connection that is in the process of opening

An open connection

A connection that is in the process of closing

A connection that is now closed and cannot be used

Commands that apply to Redis scripting (Lua).

http://redis.io/commands#scripting

Execute a Lua 5.1 script. The script does not need to define a Lua function (and should not). It is just a Lua program that will run in the context of the Redis server. All key-names should be passed via the keyArgs parameter, which allows necessary checks by Redis. Note that Lua scripts in Redis have a range of features and limitations - be sure to review the documentation.

http://redis.io/commands/eval

Ensures that the given script exists

http://redis.io/commands/script-exists and http://redis.io/commands/script-load

Commands related to server operation and configuration, rather than data.

http://redis.io/commands#server

Delete all the keys of the currently selected DB.

http://redis.io/commands/flushdb

Delete all the keys of all the existing databases, not just the currently selected one.

http://redis.io/commands/flushall

This command is often used to test if a connection is still alive, or to measure latency.

The latency in milliseconds. http://redis.io/commands/ping

The TIME command returns the current server time.

The server's current time. http://redis.io/commands/time

Get all configuration parameters matching the specified pattern.

All the configuration parameters matching this parameter are reported as a list of key-value pairs. All matching configuration parameters. http://redis.io/commands/config-get

The CONFIG SET command is used in order to reconfigure the server at runtime without the need to restart Redis. You can change both trivial parameters or switch from one to another persistence option using this command.

http://redis.io/commands/config-set

The SLAVEOF command can change the replication settings of a slave on the fly. In the proper form SLAVEOF hostname port will make the server a slave of another server listening at the specified hostname and port. If a server is already a slave of some master, SLAVEOF hostname port will stop the replication against the old server and start the synchronization against the new one, discarding the old dataset.

http://redis.io/commands/slaveof

The SLAVEOF command can change the replication settings of a slave on the fly. If a Redis server is already acting as slave, the command SLAVEOF NO ONE will turn off the replication, turning the Redis server into a MASTER. The form SLAVEOF NO ONE will stop replication, turning the server into a MASTER, but will not discard the replication. So, if the old master stops working, it is possible to turn the slave into a master and set the application to use this new master in read/write. Later when the other Redis server is fixed, it can be reconfigured to work as a slave.

Flush the Lua scripts cache; this can damage existing connections that expect the flush to behave normally, and should be used with caution.

http://redis.io/commands/script-flush

The CLIENT LIST command returns information and statistics about the client connections server in a mostly human readable format.

http://redis.io/commands/client-list

The CLIENT KILL command closes a given client connection identified by ip:port.

http://redis.io/commands/client-kill

The INFO command returns information and statistics about the server in a format that is simple to parse by computers and easy to read by humans.

http://redis.io/commands/info

Serialize the value stored at key in a Redis-specific format and return it to the user. The returned value can be synthesized back into a Redis key using the RESTORE command. The serialization format is opaque and non-standard. The serialized value does NOT contain expire information. In order to capture the time to live of the current value the PTTL command should be used.

http://redis.io/commands/dump

Create a key associated with a value that is obtained by deserializing the provided serialized value (obtained via Export).

http://redis.io/commands/restore

This command is used in order to read the slow queries log.

The number of records to return (or the entire log if not specified) http://redis.io/commands/slowlog

This command is used in order to reset the slow queries log.

http://redis.io/commands/slowlog

By default, save the DB in background. Redis forks, the parent continues to serve the clients, the child saves the DB on disk then exits. By specifying foreground = true, The SAVE commands performs a synchronous save of the dataset producing a point in time snapshot of all the data inside the Redis instance, in the form of an RDB file. A client my be able to check if the operation succeeded using the LASTSAVE command.

http://redis.io/commands/bgsave http://redis.io/commands/save

Return the time of the last DB save executed with success. A client may check if a BGSAVE command succeeded reading the LASTSAVE value, then issuing a BGSAVE command and checking at regular intervals every N seconds if LASTSAVE changed.

http://redis.io/commands/lastsave

Commands that apply to sorted sets per key. A sorted set keeps a "score" per element, and this score is used to order the elements. Duplicates are not allowed (typically, the score of the duplicate is added to the pre-existing element instead).

http://redis.io/commands#sorted_set

Adds all the specified members with the specified scores to the sorted set stored at key. It is possible to specify multiple score/member pairs. If a specified member is already a member of the sorted set, the score is updated and the element reinserted at the right position to ensure the correct ordering. If key does not exist, a new sorted set with the specified members as sole members is created, like if the sorted set was empty. If the key exists but does not hold a sorted set, an error is returned. The score values should be the string representation of a numeric value, and accepts double precision floating point numbers.

The number of elements added to the sorted sets, not including elements already existing for which the score was updated. http://redis.io/commands/zadd

Returns the sorted set cardinality (number of elements) of the sorted set stored at key.

the cardinality (number of elements) of the sorted set, or 0 if key does not exist. http://redis.io/commands/zcard

Returns the number of elements in the sorted set at key with a score between min and max. The min and max arguments have the same semantic as described for ZRANGEBYSCORE.

the number of elements in the specified score range. http://redis.io/commands/zcount

Increments the score of member in the sorted set stored at key by increment. If member does not exist in the sorted set, it is added with increment as its score (as if its previous score was 0.0). If key does not exist, a new sorted set with the specified member as its sole member is created. An error is returned when key exists but does not hold a sorted set. The score value should be the string representation of a numeric value, and accepts double precision floating point numbers. It is possible to provide a negative value to decrement the score.

http://redis.io/commands/zincrby the new score of member (a double precision floating point number), represented as string.

Returns the specified range of elements in the sorted set stored at key. The elements are considered to be ordered from the lowest to the highest score. Lexicographical order is used for elements with equal score. See ZREVRANGE when you need the elements ordered from highest to lowest score (and descending lexicographical order for elements with equal score). Both start and stop are zero-based indexes, where 0 is the first element, 1 is the next element and so on. They can also be negative numbers indicating offsets from the end of the sorted set, with -1 being the last element of the sorted set, -2 the penultimate element and so on.

http://redis.io/commands/zrange http://redis.io/commands/zrevrange list of elements in the specified range (optionally with their scores).

Returns all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max). The elements are considered to be ordered from low to high scores. The elements having the same score are returned in lexicographical order (this follows from a property of the sorted set implementation in Redis and does not involve further computation). The optional LIMIT argument can be used to only get a range of the matching elements (similar to SELECT LIMIT offset, count in SQL). Keep in mind that if offset is large, the sorted set needs to be traversed for offset elements before getting to the elements to return, which can add up to O(N) time complexity.

http://redis.io/commands/zrangebyscore http://redis.io/commands/zrevrangebyscore list of elements in the specified score range (optionally with their scores).

Returns the rank of member in the sorted set stored at key, with the scores ordered from low to high. The rank (or index) is 0-based, which means that the member with the lowest score has rank 0.

http://redis.io/commands/zrank http://redis.io/commands/zrevrank If member exists in the sorted set, Integer reply: the rank of member. If member does not exist in the sorted set or key does not exist, Bulk reply: nil.

Returns the rank of member in the sorted set stored at key, with the scores ordered from low to high. The rank (or index) is 0-based, which means that the member with the lowest score has rank 0.

Returns the score of member in the sorted set at key. If member does not exist in the sorted set, or key does not exist, nil is returned.

http://redis.io/commands/zscore the score of member (a double precision floating point number), represented as string.

Returns the score of member in the sorted set at key. If member does not exist in the sorted set, or key does not exist, nil is returned.

http://redis.io/commands/zscore the score of member (a double precision floating point number), represented as string.

Removes the specified members from the sorted set stored at key. Non existing members are ignored. An error is returned when key exists and does not hold a sorted set.

http://redis.io/commands/zrem The number of members removed from the sorted set, not including non existing members.

Removes the specified members from the sorted set stored at key. Non existing members are ignored. An error is returned when key exists and does not hold a sorted set.

http://redis.io/commands/zrem The number of members removed from the sorted set, not including non existing members.

Removes the specified members from the sorted set stored at key. Non existing members are ignored. An error is returned when key exists and does not hold a sorted set.

http://redis.io/commands/zrem The number of members removed from the sorted set, not including non existing members.

Removes the specified members from the sorted set stored at key. Non existing members are ignored. An error is returned when key exists and does not hold a sorted set.

http://redis.io/commands/zrem The number of members removed from the sorted set, not including non existing members.

Removes all elements in the sorted set stored at key with rank between start and stop. Both start and stop are 0-based indexes with 0 being the element with the lowest score. These indexes can be negative numbers, where they indicate offsets starting at the element with the highest score. For example: -1 is the element with the highest score, -2 the element with the second highest score and so forth.

http://redis.io/commands/zremrangebyrank the number of elements removed.

Removes all elements in the sorted set stored at key with a score between min and max (inclusive).

http://redis.io/commands/zremrangebyscore the number of elements removed. Since version 2.1.6, min and max can be exclusive, following the syntax of ZRANGEBYSCORE.

Computes the intersection of numkeys sorted sets given by the specified keys, and stores the result in destination.

http://redis.io/commands/zinterstore the number of elements in the resulting set.

Computes the union of numkeys sorted sets given by the specified keys, and stores the result in destination. It is mandatory to provide the number of input keys (numkeys) before passing the input keys and the other (optional) arguments.

http://redis.io/commands/zunionstore the number of elements in the resulting set.

The ZSCAN command is used in order to incrementally iterate over a collection of elements.

http://redis.io/commands/zscan

The ZSCAN command is used in order to incrementally iterate over a collection of elements.

http://redis.io/commands/zscan

Commands that apply to sets of items per key; sets have no defined order and are strictly unique. Duplicates are not allowed (typically, duplicates are silently discarded).

http://redis.io/commands#set

Add member to the set stored at key. If member is already a member of this set, no operation is performed. If key does not exist, a new set is created with member as its sole member.

true if added http://redis.io/commands/sadd

Add member to the set stored at key. If member is already a member of this set, no operation is performed. If key does not exist, a new set is created with member as its sole member.

true if added http://redis.io/commands/sadd

Add member to the set stored at key. If member is already a member of this set, no operation is performed. If key does not exist, a new set is created with member as its sole member.

the number of elements actually added to the set. http://redis.io/commands/sadd

Add member to the set stored at key. If member is already a member of this set, no operation is performed. If key does not exist, a new set is created with member as its sole member.

the number of elements actually added to the set. http://redis.io/commands/sadd

Returns the set cardinality (number of elements) of the set stored at key.

the cardinality (number of elements) of the set, or 0 if key does not exist. http://redis.io/commands/scard

Returns the members of the set resulting from the difference between the first set and all the successive sets.

list with members of the resulting set. http://redis.io/commands/sdiff

Returns the members of the set resulting from the difference between the first set and all the successive sets.

list with members of the resulting set. http://redis.io/commands/sdiff

This command is equal to SDIFF, but instead of returning the resulting set, it is stored in destination.

If destination already exists, it is overwritten. the number of elements in the resulting set. http://redis.io/commands/sdiffstore

Returns the members of the set resulting from the intersection of all the given sets.

list with members of the resulting set. http://redis.io/commands/sinter

Returns the members of the set resulting from the intersection of all the given sets.

list with members of the resulting set. http://redis.io/commands/sinter

This command is equal to SINTER, but instead of returning the resulting set, it is stored in destination.

If destination already exists, it is overwritten. the number of elements in the resulting set. http://redis.io/commands/sinterstore

Returns the members of the set resulting from the union of all the given sets.

list with members of the resulting set. http://redis.io/commands/sunion

Returns the members of the set resulting from the union of all the given sets.

list with members of the resulting set. http://redis.io/commands/sunion

This command is equal to SUNION, but instead of returning the resulting set, it is stored in destination.

If destination already exists, it is overwritten. the number of elements in the resulting set. http://redis.io/commands/sunionstore

Returns if member is a member of the set stored at key.

1 if the element is a member of the set. 0 if the element is not a member of the set, or if key does not exist. http://redis.io/commands/sismember

Returns if member is a member of the set stored at key.

1 if the element is a member of the set. 0 if the element is not a member of the set, or if key does not exist. http://redis.io/commands/sismember

Returns all the members of the set value stored at key.

all elements of the set. http://redis.io/commands/smembers

Returns all the members of the set value stored at key.

all elements of the set. http://redis.io/commands/smembers

Move member from the set at source to the set at destination. This operation is atomic. In every given moment the element will appear to be a member of source or destination for other clients.

If the source set does not exist or does not contain the specified element, no operation is performed and 0 is returned. Otherwise, the element is removed from the source set and added to the destination set. When the specified element already exists in the destination set, it is only removed from the source set. 1 if the element is moved. 0 if the element is not a member of source and no operation was performed. http://redis.io/commands/smove

Move member from the set at source to the set at destination. This operation is atomic. In every given moment the element will appear to be a member of source or destination for other clients.

Removes and returns a random element from the set value stored at key.

the removed element, or nil when key does not exist. http://redis.io/commands/spop

Removes and returns a random element from the set value stored at key.

the removed element, or nil when key does not exist. http://redis.io/commands/spop

Return a random element from the set value stored at key.

the randomly selected element, or nil when key does not exist. http://redis.io/commands/srandmember

Return a random element from the set value stored at key.

the randomly selected element, or nil when key does not exist. http://redis.io/commands/srandmember

Return an array of count distinct elements if count is positive. If called with a negative count the behavior changes and the command is allowed to return the same element multiple times. In this case the numer of returned elements is the absolute value of the specified count.

the randomly selected element, or nil when key does not exist. http://redis.io/commands/srandmember

Remove member from the set stored at key. If member is not a member of this set, no operation is performed.

1 if the element was removed. 0 if the element was not a member of the set. http://redis.io/commands/srem

Remove member from the set stored at key. If member is not a member of this set, no operation is performed.

1 if the element was removed. 0 if the element was not a member of the set. http://redis.io/commands/srem

Remove member from the set stored at key. If member is not a member of this set, no operation is performed.

1 if the element was removed. 0 if the element was not a member of the set. http://redis.io/commands/srem

Remove member from the set stored at key. If member is not a member of this set, no operation is performed.

1 if the element was removed. 0 if the element was not a member of the set. http://redis.io/commands/srem

The SSCAN command is used in order to incrementally iterate over a collection of elements.

http://redis.io/commands/sscan

The SSCAN command is used in order to incrementally iterate over a collection of elements.

http://redis.io/commands/sscan

Generic commands that apply to all/most data structures

http://redis.io/commands#generic

Removes the specified key. A key is ignored if it does not exist.

True if the key was removed. http://redis.io/commands/del

Removes the specified keys. A key is ignored if it does not exist.

The number of keys that were removed. http://redis.io/commands/del

Returns if key exists.

1 if the key exists. 0 if the key does not exist. http://redis.io/commands/exists

Set a timeout on key. After the timeout has expired, the key will automatically be deleted. A key with an associated timeout is said to be volatile in Redis terminology.

If key is updated before the timeout has expired, then the timeout is removed as if the PERSIST command was invoked on key. For Redis versions < 2.1.3, existing timeouts cannot be overwritten. So, if key already has an associated timeout, it will do nothing and return 0. Since Redis 2.1.3, you can update the timeout of a key. It is also possible to remove the timeout using the PERSIST command. See the page on key expiry for more information. 1 if the timeout was set. 0 if key does not exist or the timeout could not be set. http://redis.io/commands/expire

Remove the existing timeout on key.

1 if the timeout was removed. 0 if key does not exist or does not have an associated timeout. Available with 2.1.2 and above only http://redis.io/commands/persist

Returns all keys matching pattern

Warning: consider KEYS as a command that should only be used in production environments with extreme care. It may ruin performance when it is executed against large databases. This command is intended for debugging and special operations, such as changing your keyspace layout. Don't use KEYS in your regular application code. If you're looking for a way to find keys in a subset of your keyspace, consider using sets. http://redis.io/commands/keys

The SCAN command is used in order to incrementally iterate over a collection of elements.

http://redis.io/commands/scan

Move key from the currently selected database (see SELECT) to the specified destination database. When key already exists in the destination database, or it does not exist in the source database, it does nothing. It is possible to use MOVE as a locking primitive because of this.

1 if key was moved. 0 if key was not moved. http://redis.io/commands/move

Return a random key from the currently selected database.

the random key, or nil when the database is empty. http://redis.io/commands/randomkey

Renames key to newkey. It returns an error when the source and destination names are the same, or when key does not exist. If newkey already exists it is overwritten.

http://redis.io/commands/rename

Renames key to newkey if newkey does not yet exist. It returns an error under the same conditions as RENAME.

1 if key was renamed to newkey. 0 if newkey already exists. http://redis.io/commands/renamenx

Returns the remaining time to live (seconds) of a key that has a timeout. This introspection capability allows a Redis client to check how many seconds a given key will continue to be part of the dataset.

TTL in seconds or -1 when key does not exist or does not have a timeout. http://redis.io/commands/ttl

Returns the string representation of the type of the value stored at key. The different types that can be returned are: string, list, set, zset and hash.

type of key, or none when key does not exist. http://redis.io/commands/type

Return the number of keys in the currently selected database.

http://redis.io/commands/dbsize

Returns or stores the elements contained in the list, set or sorted set at key. By default, sorting is numeric and elements are compared by their value interpreted as double precision floating point number.

http://redis.io/commands/sort

Returns the raw DEBUG OBJECT output for a key; this command is not fully documented and should be avoided unless you have good reason, and then avoided anyway.

http://redis.io/commands/debug-object

Commands that apply to key/sub-key/value tuples, i.e. where the item is a dictionary of inner values. This can be useful for modelling members of an entity, for example.

http://redis.io/commands#hash

Removes the specified fields from the hash stored at key. Non-existing fields are ignored. Non-existing keys are treated as empty hashes and this command returns 0.

http://redis.io/commands/hdel The number of fields that were removed.

Removes the specified fields from the hash stored at key. Non-existing fields are ignored. Non-existing keys are treated as empty hashes and this command returns 0.

http://redis.io/commands/hdel The number of fields that were removed.

Returns if field is an existing field in the hash stored at key.

1 if the hash contains field. 0 if the hash does not contain field, or key does not exist. http://redis.io/commands/hexists

Returns the value associated with field in the hash stored at key.

the value associated with field, or nil when field is not present in the hash or key does not exist. http://redis.io/commands/hget

Returns the value associated with field in the hash stored at key.

the value associated with field, or nil when field is not present in the hash or key does not exist. http://redis.io/commands/hget

Returns the value associated with field in the hash stored at key.

the value associated with field, or nil when field is not present in the hash or key does not exist. http://redis.io/commands/hget

Returns the values associated with the specified fields in the hash stored at key. For every field that does not exist in the hash, a nil value is returned.

list of values associated with the given fields, in the same order as they are requested. http://redis.io/commands/hmget

Returns the values associated with the specified fields in the hash stored at key. For every field that does not exist in the hash, a nil value is returned.

list of values associated with the given fields, in the same order as they are requested. http://redis.io/commands/hmget

Returns all fields and values of the hash stored at key.

list of fields and their values stored in the hash, or an empty list when key does not exist. http://redis.io/commands/hgetall

Increments the number stored at field in the hash stored at key by increment. If key does not exist, a new key holding a hash is created. If field does not exist or holds a string that cannot be interpreted as integer, the value is set to 0 before the operation is performed.

The range of values supported by HINCRBY is limited to 64 bit signed integers. the value at field after the increment operation. http://redis.io/commands/hincrby

Returns all field names in the hash stored at key.

list of fields in the hash, or an empty list when key does not exist. http://redis.io/commands/hkeys

Returns all values in the hash stored at key.

list of values in the hash, or an empty list when key does not exist. http://redis.io/commands/hvals

Returns the number of fields contained in the hash stored at key.

number of fields in the hash, or 0 when key does not exist. http://redis.io/commands/hlen

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

1 if field is a new field in the hash and value was set. 0 if field already exists in the hash and the value was updated. http://redis.io/commands/hset

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

1 if field is a new field in the hash and value was set. 0 if field already exists in the hash and the value was updated. http://redis.io/commands/hset

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

1 if field is a new field in the hash and value was set. 0 if field already exists in the hash and the value was updated. http://redis.io/commands/hmset

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

1 if field is a new field in the hash and value was set. 0 if field already exists in the hash and no operation was performed. http://redis.io/commands/hsetnx

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

1 if field is a new field in the hash and value was set. 0 if field already exists in the hash and no operation was performed. http://redis.io/commands/hsetnx

The HSCAN command is used in order to incrementally iterate over a collection of elements.

http://redis.io/commands/hscan

The HSCAN command is used in order to incrementally iterate over a collection of elements.

http://redis.io/commands/hscan

Commands that apply to key/value pairs, where the value can be a string, a BLOB, or interpreted as a number

http://redis.io/commands#string

If key already exists and is a string, this command appends the value at the end of the string. If key does not exist it is created and set as an empty string, so APPEND will be similar to SET in this special case.

the length of the string after the append operation. http://redis.io/commands/append

Decrements the number stored at key by decrement. If the key does not exist, it is set to 0 before performing the operation. An error is returned if the key contains a value of the wrong type or contains a string that is not representable as integer. This operation is limited to 64 bit signed integers.

the value of key after the increment http://redis.io/commands/decrby http://redis.io/commands/decr

Increments the number stored at key by increment. If the key does not exist, it is set to 0 before performing the operation. An error is returned if the key contains a value of the wrong type or contains a string that is not representable as integer. This operation is limited to 64 bit signed integers.

the value of key after the increment http://redis.io/commands/incrby http://redis.io/commands/incr

the value of key after the increment http://redis.io/commands/incrbyfloat

Get the value of key. If the key does not exist the special value nil is returned. An error is returned if the value stored at key is not a string, because GET only handles string values.

the value of key, or nil when key does not exist. http://redis.io/commands/get

Get the value of key. If the key does not exist the special value nil is returned. An error is returned if the value stored at key is not a string, because GET only handles string values.

the value of key, or nil when key does not exist. http://redis.io/commands/get

Get the value of key. If the key does not exist the special value nil is returned. An error is returned if the value stored at key is not a string, because GET only handles string values.

the value of key, or nil when key does not exist. http://redis.io/commands/get

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

Negative offsets can be used in order to provide an offset starting from the end of the string. So -1 means the last character, -2 the penultimate and so forth. The function handles out of range requests by limiting the resulting range to the actual length of the string. the value of key, or nil when key does not exist. http://redis.io/commands/getrange

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

Returns the values of all specified keys. For every key that does not hold a string value or does not exist, the special value nil is returned. Because of this, the operation never fails.

list of values at the specified keys. http://redis.io/commands/mget

Returns the values of all specified keys. For every key that does not hold a string value or does not exist, the special value nil is returned. Because of this, the operation never fails.

list of values at the specified keys. http://redis.io/commands/mget

Atomically sets key to value and returns the old value stored at key. Returns an error when key exists but does not hold a string value.

the old value stored at key, or nil when key did not exist. http://redis.io/commands/getset

Atomically sets key to value and returns the old value stored at key. Returns an error when key exists but does not hold a string value.

the old value stored at key, or nil when key did not exist. http://redis.io/commands/getset

Set key to hold the string value. If key already holds a value, it is overwritten, regardless of its type.

http://redis.io/commands/set

Set key to hold the string value. If key already holds a value, it is overwritten, regardless of its type.

http://redis.io/commands/set

Set key to hold the string value. If key already holds a value, it is overwritten, regardless of its type.

http://redis.io/commands/set

Set key to hold the string value and set key to timeout after a given number of seconds.

http://redis.io/commands/setex

Set key to hold the string value and set key to timeout after a given number of seconds.

http://redis.io/commands/setex

Overwrites part of the string stored at key, starting at the specified offset, for the entire length of value. If the offset is larger than the current length of the string at key, the string is padded with zero-bytes to make offset fit. Non-existing keys are considered as empty strings, so this command will make sure it holds a string large enough to be able to set value at offset.

Note that the maximum offset that you can set is 229 -1 (536870911), as Redis Strings are limited to 512 megabytes. If you need to grow beyond this size, you can use multiple keys. Warning: When setting the last possible byte and the string value stored at key does not yet hold a string value, or holds a small string value, Redis needs to allocate all intermediate memory which can block the server for some time. On a 2010 MacBook Pro, setting byte number 536870911 (512MB allocation) takes ~300ms, setting byte number 134217728 (128MB allocation) takes ~80ms, setting bit number 33554432 (32MB allocation) takes ~30ms and setting bit number 8388608 (8MB allocation) takes ~8ms. Note that once this first allocation is done, subsequent calls to SETRANGE for the same key will not have the allocation overhead. http://redis.io/commands/setrange the length of the string after it was modified by the command.

Sets the given keys to their respective values. MSET replaces existing values with new values, just as regular SET. See MSETNX if you don't want to overwrite existing values.

MSET is atomic, so all given keys are set at once. It is not possible for clients to see that some of the keys were updated while others are unchanged. http://redis.io/commands/mset

Sets the given keys to their respective values. MSET replaces existing values with new values, just as regular SET. See MSETNX if you don't want to overwrite existing values.

MSET is atomic, so all given keys are set at once. It is not possible for clients to see that some of the keys were updated while others are unchanged. http://redis.io/commands/mset

Sets the given keys to their respective values. MSETNX will not perform any operation at all even if just a single key already exists.

Because of this semantic MSETNX can be used in order to set different keys representing different fields of an unique logic object in a way that ensures that either all the fields or none at all are set. MSETNX is atomic, so all given keys are set at once. It is not possible for clients to see that some of the keys were updated while others are unchanged. 1 if the all the keys were set, 0 if no key was set (at least one key already existed). http://redis.io/commands/msetnx

Sets the given keys to their respective values. MSETNX will not perform any operation at all even if just a single key already exists.

Set key to hold string value if key does not exist. In that case, it is equal to SET. When key already holds a value, no operation is performed.

1 if the key was set, 0 if the key was not set http://redis.io/commands/setnx

Set key to hold string value if key does not exist. In that case, it is equal to SET. When key already holds a value, no operation is performed.

1 if the key was set, 0 if the key was not set http://redis.io/commands/setnx

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

When offset is beyond the string length, the string is assumed to be a contiguous space with 0 bits. When key does not exist it is assumed to be an empty string, so offset is always out of range and the value is also assumed to be a contiguous space with 0 bits. the bit value stored at offset. http://redis.io/commands/getbit

Returns the length of the string value stored at key. An error is returned when key holds a non-string value.

the length of the string at key, or 0 when key does not exist. http://redis.io/commands/strlen

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

The bit is either set or cleared depending on value, which can be either 0 or 1. When key does not exist, a new string value is created. The string is grown to make sure it can hold a bit at offset. The offset argument is required to be greater than or equal to 0, and smaller than 232 (this limits bitmaps to 512MB). When the string at key is grown, added bits are set to 0. Warning: When setting the last possible bit (offset equal to 232 -1) and the string value stored at key does not yet hold a string value, or holds a small string value, Redis needs to allocate all intermediate memory which can block the server for some time. On a 2010 MacBook Pro, setting bit number 232 -1 (512MB allocation) takes ~300ms, setting bit number 230 -1 (128MB allocation) takes ~80ms, setting bit number 228 -1 (32MB allocation) takes ~30ms and setting bit number 226 -1 (8MB allocation) takes ~8ms. Note that once this first allocation is done, subsequent calls to SETBIT for the same key will not have the allocation overhead. the original bit value stored at offset. http://redis.io/commands/setbit

Count the number of set bits (population counting) in a string. By default all the bytes contained in the string are examined. It is possible to specify the counting operation only in an interval passing the additional arguments start and end. Like for the GETRANGE command start and end can contain negative values in order to index bytes starting from the end of the string, where -1 is the last byte, -2 is the penultimate, and so forth.

http://redis.io/commands/bitcount

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

The size of the string stored in the destination key, that is equal to the size of the longest input string. http://redis.io/commands/bitop

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

The size of the string stored in the destination key, that is equal to the size of the longest input string. http://redis.io/commands/bitop

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

The size of the string stored in the destination key, that is equal to the size of the longest input string. http://redis.io/commands/bitop

Perform a bitwise NOT operation on a key (containing a string value) and store the result in the destination key.

The size of the string stored in the destination key, that is equal to the size of the longest input string. http://redis.io/commands/bitop

This is a composite helper command, to help with using redis as a lock provider. This is achieved as a string key/value pair with timeout. If the lock does not exist (or has expired), then a new string key is created (with the supplied duration), and true is returned to indicate success. If the lock already exists, then no lock is taken, and false is returned. The value may be fetched separately, but the meaning is implementation-defined). No change is made if the lock was not successfully taken. In this case, the client should delay and retry. It is expected that a well-behaved client will also release the lock in a timely fashion via ReleaseLock.

null if the lock was successfully taken; the competing value otherwise It transpires that robust locking in redis is actually remarkably hard, and most implementations are broken in one way or another (most commonly: thread-race, or extending the lock duration when failing to take the lock).

Releases a lock that was taken successfully via TakeLock. You should not release a lock that you did not take, as this will cause problems.

Releases a lock that was taken successfully via TakeLock. The value is checked for correctness.

Extends a lock that was taken successfully via TakeLock. The value is checked for correctness.

Commands that apply to basic lists of items per key; lists preserve insertion order and have no enforced uniqueness (duplicates are allowed)

http://redis.io/commands#list

Inserts value in the list stored at key either before or after the reference value pivot.

When key does not exist, it is considered an empty list and no operation is performed. the length of the list after the insert operation, or -1 when the value pivot was not found. http://redis.io/commands/linsert

Inserts value in the list stored at key either before or after the reference value pivot.

Returns the element at index index in the list stored at key. The index is zero-based, so 0 means the first element, 1 the second element and so on. Negative indices can be used to designate elements starting at the tail of the list. Here, -1 means the last element, -2 means the penultimate and so forth.

the requested element, or nil when index is out of range. http://redis.io/commands/lindex

Sets the list element at index to value. For more information on the index argument, see LINDEX.

An error is returned for out of range indexes. http://redis.io/commands/lset

Sets the list element at index to value. For more information on the index argument, see LINDEX.

An error is returned for out of range indexes. http://redis.io/commands/lset

Returns the length of the list stored at key. If key does not exist, it is interpreted as an empty list and 0 is returned.

the length of the list at key. http://redis.io/commands/llen

Removes and returns the first element of the list stored at key.

the value of the first element, or nil when key does not exist. http://redis.io/commands/lpop

Removes and returns the first element of the list stored at key.

the value of the first element, or nil when key does not exist. http://redis.io/commands/lpop

Removes and returns the last element of the list stored at key.

the value of the first element, or nil when key does not exist. http://redis.io/commands/rpop

Removes and returns the last element of the list stored at key.

the value of the first element, or nil when key does not exist. http://redis.io/commands/rpop

IMPORTANT: blocking commands will interrupt multiplexing, and should not be used on a connection being used by parallel consumers. BLPOP is a blocking list pop primitive. It is the blocking version of LPOP because it blocks the connection when there are no elements to pop from any of the given lists. An element is popped from the head of the first list that is non-empty, with the given keys being checked in the order that they are given. A timeout of zero can be used to block indefinitely.

A null when no element could be popped and the timeout expired, otherwise the popped element. http://redis.io/commands/blpop

IMPORTANT: blocking commands will interrupt multiplexing, and should not be used on a connection being used by parallel consumers. BRPOP is a blocking list pop primitive. It is the blocking version of RPOP because it blocks the connection when there are no elements to pop from any of the given lists. An element is popped from the tail of the first list that is non-empty, with the given keys being checked in the order that they are given. A timeout of zero can be used to block indefinitely.

A null when no element could be popped and the timeout expired, otherwise the popped element. http://redis.io/commands/brpop

IMPORTANT: blocking commands will interrupt multiplexing, and should not be used on a connection being used by parallel consumers. BRPOPLPUSH is the blocking variant of RPOPLPUSH. When source contains elements, this command behaves exactly like RPOPLPUSH. When source is empty, Redis will block the connection until another client pushes to it or until timeout is reached. A timeout of zero can be used to block indefinitely.

For example: consider source holding the list a,b,c, and destination holding the list x,y,z. Executing RPOPLPUSH results in source holding a,b and destination holding c,x,y,z. If source does not exist, the value nil is returned and no operation is performed. If source and destination are the same, the operation is equivalent to removing the last element from the list and pushing it as first element of the list, so it can be considered as a list rotation command. the element being popped and pushed. http://redis.io/commands/brpoplpush

Inserts value at the head of the list stored at key. If key does not exist and createIfMissing is true, it is created as empty list before performing the push operation.

the length of the list after the push operation. http://redis.io/commands/lpush http://redis.io/commands/lpushx

Inserts value at the head of the list stored at key. If key does not exist and createIfMissing is true, it is created as empty list before performing the push operation.

the length of the list after the push operation. http://redis.io/commands/lpush http://redis.io/commands/lpushx

Inserts value at the tail of the list stored at key. If key does not exist and createIfMissing is true, it is created as empty list before performing the push operation.

the length of the list after the push operation. http://redis.io/commands/rpush http://redis.io/commands/rpushx

Inserts value at the tail of the list stored at key. If key does not exist and createIfMissing is true, it is created as empty list before performing the push operation.

the length of the list after the push operation. http://redis.io/commands/rpush http://redis.io/commands/rpushx

Removes the first count occurrences of elements equal to value from the list stored at key.

The count argument influences the operation in the following ways: count > 0: Remove elements equal to value moving from head to tail. count < 0: Remove elements equal to value moving from tail to head. count = 0: Remove all elements equal to value. For example, LREM list -2 "hello" will remove the last two occurrences of "hello" in the list stored at list. the number of removed elements. http://redis.io/commands/lrem

Removes the first count occurrences of elements equal to value from the list stored at key.

Trim an existing list so that it will contain only the specified range of elements specified. Both start and stop are zero-based indexes, where 0 is the first element of the list (the head), 1 the next element and so on. start and end can also be negative numbers indicating offsets from the end of the list, where -1 is the last element of the list, -2 the penultimate element and so on.

For example: LTRIM foobar 0 2 will modify the list stored at foobar so that only the first three elements of the list will remain. Out of range indexes will not produce an error: if start is larger than the end of the list, or start > end, the result will be an empty list (which causes key to be removed). If end is larger than the end of the list, Redis will treat it like the last element of the list. http://redis.io/commands/ltrim

Trim an existing list so that it will contain only the specified count.

http://redis.io/commands/ltrim

Atomically returns and removes the last element (tail) of the list stored at source, and pushes the element at the first element (head) of the list stored at destination.

Returns the specified elements of the list stored at key. The offsets start and end are zero-based indexes, with 0 being the first element of the list (the head of the list), 1 being the next element and so on.

These offsets can also be negative numbers indicating offsets starting at the end of the list. For example, -1 is the last element of the list, -2 the penultimate, and so on. list of elements in the specified range. http://redis.io/commands/lrange

Delete all the keys of the currently selected DB.

Delete all the keys of all the existing databases, not just the currently selected one.

This command is often used to test if a connection is still alive, or to measure latency.

The latency in milliseconds. http://redis.io/commands/ping

See SortedSets.Add

See SortedSets.GetLength

See SortedSets.Increment

See SortedSets.GetRange

See SortedSets.RemoveRange

Add an item to a set

Returns the number of items in a set

Intersect multiple sets

Union multiple sets

Intersect multiple sets, storing the result

Is the given value in the set?

Gets all members of a set

Remove an item from a set

Removes a key from the database.

Removes multiple keys from the database.

Returns if key exists.

Set a timeout on key. After the timeout has expired, the key will automatically be deleted. A key with an associated timeout is said to be volatile in Redis terminology.

Remove the existing timeout on key.

Returns all keys matching pattern.

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

Return a random key from the currently selected database.

the random key, or nil when the database is empty. http://redis.io/commands/randomkey

Renames a key in the database, overwriting any existing value; the source key must exist and be different to the destination.

Returns the remaining time to live (seconds) of a key that has a timeout.

Enumerate all keys in a hash.

Returns all fields and values of the hash stored at key.

list of fields and their values stored in the hash, or an empty list when key does not exist.

Increment a field on a hash by an amount (1 by default)

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

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

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

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

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

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

1 if field is a new field in the hash and value was set. 0 if field already exists in the hash and no operation was performed.

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

1 if field is a new field in the hash and value was set. 0 if field already exists in the hash and no operation was performed.

Returns the value associated with field in the hash stored at key.

the value associated with field, or nil when field is not present in the hash or key does not exist.

Returns the value associated with field in the hash stored at key.

the value associated with field, or nil when field is not present in the hash or key does not exist.

Returns the values associated with the specified fields in the hash stored at key. For every field that does not exist in the hash, a nil value is returned.

list of values associated with the given fields, in the same order as they are requested.

Returns the values associated with the specified fields in the hash stored at key. For every field that does not exist in the hash, a nil value is returned.

list of values associated with the given fields, in the same order as they are requested.

Removes the specified field from the hash stored at key. Non-existing fields are ignored. Non-existing keys are treated as empty hashes and this command returns 0.

Removes the specified fields from the hash stored at key. Non-existing fields are ignored. Non-existing keys are treated as empty hashes and this command returns 0.

Returns if field is an existing field in the hash stored at key.

1 if the hash contains field. 0 if the hash does not contain field, or key does not exist.

Returns all field names in the hash stored at key.

list of fields in the hash, or an empty list when key does not exist.

Returns all values in the hash stored at key.

list of values in the hash, or an empty list when key does not exist.

Returns the number of fields contained in the hash stored at key.

number of fields in the hash, or 0 when key does not exist.

See Strings.Get

See Strings.GetString

See Strings.Increment

See Strings.Decrement

See Strings.Set

See Strings.SetIfNotExists

See Strings.Append

See Strings.Set

the requested element, or nil when index is out of range.

Query the number of items in a list

The database to operate on The key of the list Whether to overtake unsent messages The number of items in the list, or 0 if it does not exist

Removes an item from the start of a list

The database to operatate on The list to remove an item from Whether to overtake unsent messages The contents of the item removed, or null if empty

Removes an item from the end of a list

The database to operatate on The list to remove an item from Whether to overtake unsent messages The contents of the item removed, or null if empty

Prepend an item to a list

The database to operate on The key of the list The item to add Whether to overtake unsent messages The number of items now in the list

Prepend an item to a list

The database to operate on The key of the list The item to add Whether to overtake unsent messages The number of items now in the list

Append an item to a list

The database to operate on The key of the list The item to add Whether to overtake unsent messages The number of items now in the list

Append an item to a list

The database to operate on The key of the list The item to add Whether to overtake unsent messages The number of items now in the list

See Lists.RemoveLastAndAddFirst

See Lists.Range

Creates a new RedisConnection to a designated server

Creates a child RedisConnection, such as for a RedisTransaction

Allows multiple commands to be buffered and sent to redis as a single atomic unit

Allows multiple commands to be buffered and sent to redis collectively, but without any guarantee of atomicity

Configures an automatic keep-alive PING at a pre-determined interval; this is especially useful if CONFIG GET is not available.

The message to supply to callers when rejecting messages

Closes the connection; either draining the unsent queue (to completion), or abandoning the unsent queue.

Called during connection init, but after the AUTH is sent (if needed)

Creates a pub/sub connection to the same redis server

Releases any resources associated with the connection

Query usage metrics for this connection

Give some information about the oldest incomplete (but sent) message on the server

Takes a server out of "slave" mode, to act as a replication master.

Note that some operations (transaction conditions, etc) require flushing - this will still occur even if the buffer is only part full.

Resume eager-flushing (flushing if the write-queue becomes empty briefly). See SuspendFlush for full usage.

Posts a message to the given channel.

the number of clients that received the message.

Posts a message to the given channel.

the number of clients that received the message.

Commands that apply to Redis scripting (Lua).

http://redis.io/commands#scripting

Commands related to server operation and configuration, rather than data.

http://redis.io/commands#server

http://redis.io/commands#sorted_set

Commands that apply to sets of items per key; sets have no defined order and are strictly unique. Duplicates are not allowed (typically, duplicates are silently discarded).

http://redis.io/commands#set

Generic commands that apply to all/most data structures

http://redis.io/commands#generic

Commands that apply to key/sub-key/value tuples, i.e. where the item is a dictionary of inner values. This can be useful for modelling members of an entity, for example.

http://redis.io/commands#hash

Commands that apply to key/value pairs, where the value can be a string, a BLOB, or interpreted as a number

http://redis.io/commands#string

Commands that apply to basic lists of items per key; lists preserve insertion order and have no enforced uniqueness (duplicates are allowed)

http://redis.io/commands#list

How frequently should keep-alives be sent?

Time (in milliseconds) since the last command was sent

Indicates the number of messages that have not yet been sent to the server.

Constants representing the different storage devices in redis

Returned for a key that does not exist

Redis Lists are simply lists of strings, sorted by insertion order. It is possible to add elements to a Redis List pushing new elements on the head (on the left) or on the tail (on the right) of the list.

http://redis.io/topics/data-types#lists

Strings are the most basic kind of Redis value. Redis Strings are binary safe, this means that a Redis string can contain any kind of data, for instance a JPEG image or a serialized Ruby object.

http://redis.io/topics/data-types#strings

Redis Sets are an unordered collection of Strings. It is possible to add, remove, and test for existence of members in O(1) (constant time regardless of the number of elements contained inside the Set).

http://redis.io/topics/data-types#sets

Redis Sorted Sets are, similarly to Redis Sets, non repeating collections of Strings. The difference is that every member of a Sorted Set is associated with score, that is used in order to take the sorted set ordered, from the smallest to the greatest score.

http://redis.io/topics/data-types#sorted-sets

Redis Hashes are maps between string field and string values, so they are the perfect data type to represent objects (for instance Users with a number of fields like name, surname, age, and so forth)

http://redis.io/topics/data-types#hashes

Event data relating to an exception in Redis

The exception that occurred

What the system was doing when this error occurred

True if this error has rendered the connection unusable

With the AGGREGATE option, it is possible to specify how the results of the union are aggregated. This option defaults to SUM, where the score of an element is summed across the inputs where it exists. When this option is set to either MIN or MAX, the resulting set will contain the minimum or maximum score of an element across the inputs where it exists.

The score of an element is summed across the inputs where it exists

The resulting set will contain the minimum score of an element across the inputs where it exists

The resulting set will contain the maximum score of an element across the inputs where it exists

What type of server does this represent

The server is not yet connected, or is not recognised

The server is a master node, suitable for read and write

The server is a replication slave, suitable for read

The server is a sentinel, used for anutomated configuration and failover

The server is part of a cluster

Summary statistics for the RedisConnection

Obtain a string representation of the counters

How frequently should keep-alives be sent?

Time (in milliseconds) since the last command was sent

Time (in milliseconds) since the last command was sent explicitly because of a keep-alive

The state of the server connection

The number of callbacks executed (total) synchronously

The number of callbacks executed (total) asynchronously

The number of callbacks executing (currently) synchronously

The number of callbacks executing (currently) asynchronously

The number of messages sent to the Redis server

The number of messages received from the Redis server

The number of queued messages that were withdrawn without being sent

The number of operations that timed out

The number of operations that were sent ahead of queued items

The number of messages waiting to be sent

The number of error messages received by the server

The number of messages that have been sent and are waiting for a response

The current time (milliseconds) taken to send a Redis PING command and receive a PONG reply

Provides basic information about the features available on a particular version of Redis

Create a new RedisFeatures instance for the given version

Create a string representation of the available features

The Redis version of the server

Is the PERSIST operation supported?

Can EXPIRE be used to set expiration on a key that is already volatile (i.e. has an expiration)?

Does HDEL support varadic usage?

Is STRLEN available?

Is SETRANGE available?

Is RPUSHX and LPUSHX available?

Does SADD support varadic usage?

Does INCRBYFLOAT / HINCRBYFLOAT exist?

Does EVAL / EVALSHA / etc exist?

Does SRANDMEMBER support "count"?

Does TIME exist?

Does BITOP / BITCOUNT exist?

Is LINSERT available?

Is CLIENT SETNAME available?

Does SET have the EX|PX|NX|XX extensions?

Are cursor-based scans available?

Represents a group of operations that will be sent to the server in a group

Not supported, as nested transactions are not available.

Not supported, as nested batches are not available.

Release any resources held by this transaction/batch.

Discards any buffered commands; the transaction/batch may subsequently be re-used to buffer additional blocks of commands if needed.

Called before opening a connection

Send the buffered commands

The underlying connection that this batch operates upon

Features available to the redis server

The version of the connected redis server

Should a QUIT be sent when closing the connection?

Represents a group of redis messages that will be sent as a single atomic

Sends all currently buffered commands to the redis server in a single unit; the transaction may subsequently be re-used to buffer additional blocks of commands if needed.

Add a precondition to be enforced for this transaction

A redis-related exception; this could represent a message from the server, or a protocol error talking to the server.

Create a new RedisException

A redis-related exception, where an attempt has been made to change a value on a readonly slave (2.6 or above)

Create a new RedisReadonlySlaveException

Provides a Redis connection for listening for (and handling) the subscriber part of a pub/sub implementation. Messages are sent using RedisConnection.Publish.

Create a new RedisSubscriberConnection instance

The server to connect to (IP address or name) The port on the server to connect to; typically 3679 The timeout to use during IO operations; this can usually be left unlimited If the server is secured, the server password (null if not secured) The maximum number of unsent messages to enqueue before new requests are blocking calls

Called during connection init, but after the AUTH is sent (if needed)

Whether to release any queued messages

Invoked when we have completed the handshake

Subscribe to a channel

The channel name A callback to invoke when messages are received on this channel; note that the MessageReceived event will also be raised, so this callback can be null. Channels are server-wide; they are not per-database

Subscribe to a set of channels

The channel names A callback to invoke when messages are received on these channel; note that the MessageReceived event will also be raised, so this callback can be null. Channels are server-wide; they are not per-database

Subscribe to a set of pattern (using wildcards, for exmaple "Foo*")

The pattern to subscribe A callback to invoke when matching messages are received; this can be null as the MessageReceived event will also be raised Channels are server-wide, not per-database

Subscribe to a set of patterns (using wildcards, for exmaple "Foo*")

The patterns to subscribe A callback to invoke when matching messages are received; this can be null as the MessageReceived event will also be raised Channels are server-wide, not per-database

Unsubscribe from a channel

The channel name Channels are server-wide; they are not per-database

Unsubscribe from a set of channels

The channel names Channels are server-wide; they are not per-database

Unsubscribe from a pattern (which must match a pattern previously subscribed)

The pattern to unsubscribe Channels are server-wide, not per-database

Unsubscribe from a set of patterns (which must match patterns previously subscribed)

The patterns to unsubscribe Channels are server-wide, not per-database

This event is raised when a message is received on any subscribed channel; this is supplemental to any direct callbacks specified.

Should a QUIT be sent when closing the connection?

The number of subscriptions currently help by the current connection (as reported by the server during the last subsribe/unsubscribe operation)

Indicates how incoming messages should be completed / dispatched.

Results are always completed synchronously; this guarantees to preserve order, but means that long-running continuations may block other operations from completing even when the data is available.

Results are dispatched asynchronously; no guarantee of order is offered.

The system will attempt to determine whether any given operation has a continuation; if it does, it will dispatch it concurrently to avoid risk of blocking scenarios; if it does not, it will complete it synchronously for performance.

Indicates the reason that a connection was shut down

The connection is not shut down

The connection was closed by the client calling close

The connection was closed by the client being disposed

The server closed the connection (EOF)

The connection was terminated due to an unexpected error

Utility classes for working safely with tasks

Create a task wrapper that is safe to use with "await", by avoiding callback-inlining