StackExchange.Redis

Specifies how elements should be aggregated when combining sorted sets

The values of the combined elements are added

The least value of the combined elements is used

The greatest value of the combined elements is used

Utility methods

Create a dictionary from an array of HashEntry values

Create a dictionary from an array of SortedSetEntry values

Create a dictionary from an array of key/value pairs

Create a dictionary from an array of string pairs

Describes a hash-field (a name/value pair)

Initializes a HashEntry value

Converts to a key/value pair

Converts from a key/value pair

See Object.ToString()

See Object.GetHashCode()

Compares two values for equality

Compares two values for non-equality

The name of the hash field

The value of the hash field

The name of the hash field

Describes internal errors (mainly intended for debugging)

Gets the connection-type of the failing connection

Gets the failing server-endpoint (this can be null)

Gets the exception if available (this can be null)

The underlying origin of the error

Represents a pub/sub channel name

Indicate whether two channel names are not equal

Indicate whether two channel names are equal

See Object.Equals

Indicate whether two channel names are equal

See Object.GetHashCode

Obtains a string representation of the channel name

Create a channel name from a String

Create a channel name from a Byte[]

Obtain the channel name as a Byte[]

Obtain the channel name as a String

Indicates whether the channel-name is either null or a zero-length value

Bitwise operators

And

Xor

Not

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

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 state of an individual client connection to redis

Format the object as a string

Address (host and port) of the client

total duration of the connection in seconds

current database ID

The flags associated with this connection

The host of the client (typically an IP address)

idle time of the connection in seconds

last command played

The name allocated to this connection, if any

number of pattern matching subscriptions

The port of the client

The raw content from redis

number of channel subscriptions

number of commands in a MULTI/EXEC context

This does a few important things: 1: it suppresses error events for commands that the user isn't interested in (i.e. "why does my standalone server keep saying ERR unknown command 'cluster' ?") 2: it allows the initial PING and GET (during connect) to get queued rather than be rejected as no-server-available (note that this doesn't apply to handshake messages, as they bypass the queue completely) 3: it disables non-pref logging, as it is usually server-targeted

Things with the potential to cause harm, or to reveal configuration information

Indicates a range of slots served by a cluster node

Create a new SlotRange value

Indicates whether two ranges are not equal

Indicates whether two ranges are equal

Try to parse a string as a range

Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object.

See Object.Equals

Indicates whether two ranges are equal

See Object.GetHashCode()

See Object.ToString()

The start of the range (inclusive)

The end of the range (inclusive)

Describes the state of the cluster as reported by a single node

Gets the node that serves the specified slot

Gets all nodes contained in the configuration

The node that was asked for the configuration

Obtain the node relating to a specified endpoint

Represents the configuration of a single node in a cluster configuration

See Object.Equals

Indicates whether two ClusterNode instances are equivalent

See object.GetHashCode()

See Object.ToString()

Gets all child nodes of the current node

Gets the endpoint of the current node

Gets whether this node is a slave

Gets the unique node-id of the current node

Gets the parent node of the current node

Gets the unique node-id of the parent of the current node

The configuration as reported by the server

The slots owned by this server

Represents the information known about long-running commands

Deduces a link to the redis documentation about the specified command

The array composing the arguments of the command.

The amount of time needed for its execution

The time at which the logged command was processed.

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.

Describes a pre-condition used in a redis transaction

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

Enforces that the given hash-field must exist

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

Enforces that the given hash-field must not exist

Enforces that the given key must exist

Enforces that the given key must not exist

Enforces that the given key must have the specified value

Enforces that the given key must not have the specified value

Indicates the status of a condition as part of a transaction

Indicates whether the condition was satisfied

Specifies the proxy that is being used to communicate to redis

Direct communication to the redis server(s)

Communication via twemproxy

The options relevant to a set of redis connections

Parse the configuration from a comma-delimited configuration string

Create a copy of the configuration

Resolve the default port for any endpoints that did not have a port explicitly specified

Returns the effective configuration string for this configuration

A LocalCertificateSelectionCallback delegate responsible for selecting the certificate used for authentication; note that this cannot be specified in the configuration-string.

A RemoteCertificateValidationCallback delegate responsible for validating the certificate supplied by the remote party; note that this cannot be specified in the configuration-string.

Gets or sets whether connect/configuration timeouts should be explicitly notified via a TimeoutException

Indicates whether admin operations should be allowed

Indicates whether the connection should be encrypted

Automatically encodes and decodes channels

The client name to user for all connections

The command-map associated with this configuration

Channel to use for broadcasting and listening for configuration change notification

Specifies the time in milliseconds that should be allowed for connection

The server version to assume

The endpoints defined for this configuration

Specifies the time in seconds at which connections should be pinged to ensure validity

The password to use to authenticate with the server

Indicates whether admin operations should be allowed

Indicates whether endpoints should be resolved via DNS before connecting

The service name used to resolve a service via sentinel

Gets or sets the SocketManager instance to be used with these options; if this is null a per-multiplexer SocketManager is created automatically.

The target-host to use when validating SSL certificate; setting a value here enables SSL mode

Specifies the time in milliseconds that the system should allow for synchronous operations

Tie-breaker used to choose between masters (must match the endpoint exactly)

The size of the output buffer to use

Illustrates the counters associated with an individual connection

See Object.ToString()

The number of operations that have been completed asynchronously

The number of operations that have been completed synchronously

The type of this connection

The number of operations that failed to complete asynchronously

Indicates if there are any pending items or failures on this connection

Indicates the total number of messages despatched to a non-preferred endpoint, for example sent to a master when the caller stated a preference of slave

The number of operations performed on this connection

Operations that have been requested, but which have not yet been sent to the server

Operations for which the response has been processed, but which are awaiting asynchronous completion

Operations that have been sent to the server, but which are awaiting a response

The number of sockets used by this logical connection (total, including reconnects)

The number of subscriptions (with and without patterns) currently held against this connection

Indicates the total number of outstanding items against this connection

Indicates the total number of writers items against this connection

Contains information about a server connection failure

Gets the connection-type of the failing connection

Gets the failing server-endpoint

Gets the exception if available (this can be null)

The type of failure

The known types of connection failure

This event is not a failure

No viable connections were available for this operation

The socket for this connection failed

The connection did not authenticate correctly

An unexpected response was received from the server

An unknown internal error occurred

The socket was closed

The database is loading and is not available for use

It has not been possible to create an intial connection to the redis server(s)

Represents an inter-related group of connections to redis servers

Get summary statistics associates with this server

Write the configuration of all servers to an output stream

Gets all endpoints defined on the server

Wait for a given asynchronous operation to complete (or timeout)

Wait for the given asynchronous operations to complete (or timeout)

Compute the hash-slot of a specified key

Create a new ConnectionMultiplexer instance

Obtain a pub/sub subscriber connection to the specified server

Obtain an interactive connection to a database inside redis

Obtain a configuration API for an individual server

Reconfigure the current connections based on the existing configuration

Provides a text overview of the status of all connections

See Object.ToString()

Close all connections and release all resources associated with this object

Release all resources associated with this object

Obtains the log of unusual busy patterns

Resets the log of unusual busy patterns

Request all compatible clients to reconfigure or reconnect

The number of instances known to have received the message (however, the actual number can be higher)

Request all compatible clients to reconfigure or reconnect

The number of instances known to have received the message (however, the actual number can be higher)

Gets the client-name that will be used on all new connections

Gets the configuration of the connection

A server replied with an error message;

Used internally to synchronize loggine without depending on locking the log instance

Raised whenever a physical connection fails

Raised whenever an internal error occurs (this is primarily for debugging)

Raised whenever a physical connection is established

Raised when configuration changes are detected

Raised when nodes are explicitly requested to reconfigure via broadcast; this usually means master/slave changes

Gets the timeout associated with the connections

Raised when a hash-slot has been relocated

The number of operations that have been performed on all connections

Gets or sets whether asynchronous operations should be invoked in a way that guarantees their original delivery order

Indicates whether any servers are connected

Should exceptions include identifiable details? (key names, additional .Data annotations)

Limit at which to start recording unusual busy patterns (only one log will be retained at a time; set to a negative value to disable this feature)

The type of a connection

Not connection-type related

An interactive connection handles request/response commands for accessing data on demand

A subscriber connection recieves unsolicted messages from the server as pub/sub events occur

A list of endpoints

Format an endpoint

Attempt to parse a string into an EndPoint

Adds a new endpoint to the list

See Collection<T>.InsertItem()

See Collection<T>.SetItem()

Event information related to redis endpoints

The endpoint involved in this event (this can be null)

When performing a range query, by default the start / stop limits are inclusive; however, both can also be specified separately as exclusive

Both start and stop are inclusive

Start is exclusive, stop is inclusive

Start is inclusive, stop is exclusive

Both start and stop are exclusive

Which settings to export

No options

The output of INFO

The output of CONFIG GET *

The output of CLIENT LIST

The output of CLUSTER NODES

Everything available

Represents a block of operations that will be sent to the server together; this can be useful to reduce packet fragmentation on slow connections - it can improve the time to get *all* the operations processed, with the trade-off of a slower time to get the *first* operation processed; this is usually a good thing. Unless this batch is a transaction, there is no guarantee that these operations will be processed either contiguously or atomically by the server.

Describes functionality that is common to both standalone redis servers and redis clusters

Common operations available to all redis connections

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

The observed latency. http://redis.io/commands/ping

Wait for a given asynchronous operation to complete (or timeout), reporting which

Wait for a given asynchronous operation to complete (or timeout)

Wait for the given asynchronous operations to complete (or timeout)

Gets the multiplexer that created this instance

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

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

Decrement the specified field of an hash stored at key, and representing a floating point number, by the specified decrement. If the field does not exist, it is set to 0 before performing the operation.

The precision of the output is fixed at 17 digits after the decimal point regardless of the actual internal precision of the computation. the value at field after the decrement operation. http://redis.io/commands/hincrbyfloat

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 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

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.Because a non-existing keys are treated as empty hashes, running HMGET against a non-existing key will return a list of nil values.

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

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

Increment the specified field of an hash stored at key, and representing a floating point number, by the specified increment. If the field does not exist, it is set to 0 before performing the operation.

The precision of the output is fixed at 17 digits after the decimal point regardless of the actual internal precision of the computation. the value at field after the increment operation. http://redis.io/commands/hincrbyfloat

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

http://redis.io/commands/hmset

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 http://redis.io/commands/hsetnx

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

Adds the element to the HyperLogLog data structure stored at the variable name specified as first argument.

true if at least 1 HyperLogLog internal register was altered. false otherwise. http://redis.io/commands/pfadd

Adds all the element arguments to the HyperLogLog data structure stored at the variable name specified as first argument.

true if at least 1 HyperLogLog internal register was altered. false otherwise. http://redis.io/commands/pfadd

Returns the approximated cardinality computed by the HyperLogLog data structure stored at the specified variable, or 0 if the variable does not exist.

The approximated number of unique elements observed via HyperLogLogAdd. http://redis.io/commands/pfcount

Merge multiple HyperLogLog values into an unique value that will approximate the cardinality of the union of the observed Sets of the source HyperLogLog structures.

http://redis.io/commands/pfmerge

Merge multiple HyperLogLog values into an unique value that will approximate the cardinality of the union of the observed Sets of the source HyperLogLog structures.

http://redis.io/commands/pfmerge

Inidicate exactly which redis server we are talking to

Indicates whether the instance can communicate with the server (resolved using the supplied key and optional flags)

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

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 serialized value. http://redis.io/commands/dump

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 http://redis.io/commands/pexpire http://redis.io/commands/persist

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/expireat http://redis.io/commands/pexpireat http://redis.io/commands/persist

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

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

1 if the timeout was removed. 0 if key does not exist or does not have an associated timeout. http://redis.io/commands/persist

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.

http://redis.io/commands/rename http://redis.io/commands/renamenx

Create a key associated with a value that is obtained by deserializing the provided serialized value (obtained via DUMP). If ttl is 0 the key is created without any expire, otherwise the specified expire time(in milliseconds) is set.

http://redis.io/commands/restore

Returns the remaining time to live 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, or nil 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

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

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

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

Insert the specified value at the head of the list stored at key. If key does not exist, it is created as empty list before performing the push operations.

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

Insert all the specified values at the head of the list stored at key. If key does not exist, it is created as empty list before performing the push operations. Elements are inserted one after the other to the head of the list, from the leftmost element to the rightmost element. So for instance the command LPUSH mylist a b c will result into a list containing c as first element, b as second element and a as third element.

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

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

Returns the specified elements of the list stored at key. The offsets start and stop 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. Note that if you have a list of numbers from 0 to 100, LRANGE list 0 10 will return 11 elements, that is, the rightmost item is included.

list of elements in the specified range. http://redis.io/commands/lrange

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.

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

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

http://redis.io/commands/rpop

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.

the element being popped and pushed. http://redis.io/commands/rpoplpush

Insert the specified value at the tail of the list stored at key. If key does not exist, 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

Insert all the specified values at the tail of the list stored at key. If key does not exist, it is created as empty list before performing the push operation. Elements are inserted one after the other to the tail of the list, from the leftmost element to the rightmost element. So for instance the command RPUSH mylist a b c will result into a list containing a as first element, b as second element and c as third element.

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

Sets the list element at index to value. For more information on the index argument, see ListGetByIndex. An error is returned for out of range indexes.

http://redis.io/commands/lset

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

http://redis.io/commands/ltrim

Extends a lock, if the token value is correct

Queries the token held against a lock

Releases a lock, if the token value is correct

Takes a lock (specifying a token value) if it is not already taken

Posts a message to the given channel.

the number of clients that received the message. http://redis.io/commands/publish

Execute a Lua script against the server

http://redis.io/commands/eval, http://redis.io/commands/evalsha A dynamic representation of the script's result

Execute a Lua script against the server using just the SHA1 hash

http://redis.io/commands/evalsha A dynamic representation of the script's result

Add the specified member to the set stored at key. Specified members that are already a member of this set are ignored. If key does not exist, a new set is created before adding the specified members.

True if the specified member was not already present in the set, else False http://redis.io/commands/sadd

Add the specified members to the set stored at key. Specified members that are already a member of this set are ignored. If key does not exist, a new set is created before adding the specified members.

the number of elements that were added to the set, not including all the elements already present into the set. http://redis.io/commands/sadd

This command is equal to SetCombine, 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 http://redis.io/commands/sinterstore http://redis.io/commands/sdiffstore

This command is equal to SetCombine, 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 http://redis.io/commands/sinterstore http://redis.io/commands/sdiffstore

Returns the members of the set resulting from the specified operation against the given sets.

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

Returns the members of the set resulting from the specified operation against the given sets.

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

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

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

an array of elements, or an empty array when key does not exist http://redis.io/commands/srandmember

Remove the specified member from the set stored at key. Specified members that are not a member of this set are ignored.

True if the specified member was already present in the set, else False http://redis.io/commands/srem

Remove the specified members from the set stored at key. Specified members that are not a member of this set are ignored.

the number of members that were removed from the set, not including non existing members. http://redis.io/commands/srem

Sorts a list, set or sorted set (numerically or alphabetically, ascending by default); By default, the elements themselves are compared, but the values can also be used to perform external key-lookups using the by parameter. By default, the elements themselves are returned, but external key-lookups (one or many) can be performed instead by specifying the get parameter (note that # specifies the element itself, when used in get). Referring to the redis SORT documentation for examples is recommended. When used in hashes, by and get can be used to specify fields using -> notation (again, refer to redis documentation).

http://redis.io/commands/sort Returns the number of elements stored in the new list

http://redis.io/commands/sort Returns the sorted elements, or the external values if get is specified

Adds the specified member with the specified score to the sorted set stored at key. If the 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.

True if the value was added, False if it already existed (the score is still updated) http://redis.io/commands/zadd

Adds all the specified members with the specified scores to the sorted set stored at key. 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.

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

Computes a set operation over two sorted sets, and stores the result in destination, optionally performing a specific aggregation (defaults to sum)

http://redis.io/commands/zunionstore http://redis.io/commands/zinterstore the number of elements in the resulting sorted set at destination

Computes a set operation over multiple sorted sets (optionally using per-set weights), and stores the result in destination, optionally performing a specific aggregation (defaults to sum)

http://redis.io/commands/zunionstore http://redis.io/commands/zinterstore the number of elements in the resulting sorted set at destination

Decrements the score of member in the sorted set stored at key by decrement. If member does not exist in the sorted set, it is added with -decrement as its score (as if its previous score was 0.0).

the new score of member http://redis.io/commands/zincrby

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

the new score of member http://redis.io/commands/zincrby

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

When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns the number of elements in the sorted set at key with a value between min and max.

the number of elements in the specified score range. When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns all the elements in the sorted set at key with a value between min and max.

Returns the specified range of elements in the sorted set stored at key. By default the elements are considered to be ordered from the lowest to the highest score. Lexicographical order is used 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.

list of elements in the specified range http://redis.io/commands/zrange http://redis.io/commands/zrevrange

list of elements in the specified score range http://redis.io/commands/zrangebyscore http://redis.io/commands/zrevrangebyscore

When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns all the elements in the sorted set at key with a value between min and max.

http://redis.io/commands/zrangebylex list of elements in the specified score range.

Returns the rank of member in the sorted set stored at key, by default 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.

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

Removes the specified member from the sorted set stored at key. Non existing members are ignored.

True if the member existed in the sorted set and was removed; False otherwise. http://redis.io/commands/zrem

Removes the specified members from the sorted set stored at key. Non existing members are ignored.

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

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.

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

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

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

When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command removes all elements in the sorted set stored at key between the lexicographical range specified by min and max.

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

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.

the score of member http://redis.io/commands/zscore

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

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.

The number of bits set to 1 http://redis.io/commands/bitcount

Perform a bitwise operation between multiple keys (containing string values) and store the result in the destination key. The BITOP command supports four bitwise operations; note that NOT is a unary operator: the second key should be omitted in this case and only the first key will be considered. The result of the operation is always stored at destkey.

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 operation between multiple keys (containing string values) and store the result in the destination key. The BITOP command supports four bitwise operations; note that NOT is a unary operator. The result of the operation is always stored at destkey.

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

Return the position of the first bit set to 1 or 0 in a string. The position is returned thinking at the string as an array of bits from left to right where the first byte most significant bit is at position 0, the second byte most significant big is at position 8 and so forth. An start and end may be specified; these are in bytes, not bits; 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.

The command returns the position of the first bit set to 1 or 0 according to the request. If we look for set bits(the bit argument is 1) and the string is empty or composed of just zero bytes, -1 is returned. http://redis.io/commands/bitpos

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

Decrements the string representing a floating point number stored at key by the specified increment. If the key does not exist, it is set to 0 before performing the operation. The precision of the output is fixed at 17 digits after the decimal point regardless of the actual internal precision of the computation.

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

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.

http://redis.io/commands/mget

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.

the bit value stored at offset. http://redis.io/commands/getbit

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 substring of the string value stored at key http://redis.io/commands/getrange

Atomically sets key to value and returns the old value stored at key.

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

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

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

Increment the string representing a floating point number stored at key by the specified increment. If the key does not exist, it is set to 0 before performing the operation. The precision of the output is fixed at 17 digits after the decimal point regardless of the actual internal precision of the computation.

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

Returns the length of the string value stored at key.

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

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

Sets the given keys to their respective values. If "not exists" is specified, this will not perform any operation at all even if just a single key already exists.

True if the keys were set, else False http://redis.io/commands/mset http://redis.io/commands/msetnx

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 original bit value stored at offset. http://redis.io/commands/setbit

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.

the length of the string after it was modified by the command. http://redis.io/commands/setrange

Execute the batch operation, sending all queued commands to the server. Note that this operation is neither synchronous nor truly asyncronous - it simply enqueues the buffered messages. To check on completion, you should check the individual responses.

The direction in which to sequence elements

Ordered from low values to high values

Ordered from high values to low values

Common operations available to all redis connections

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

The observed latency. http://redis.io/commands/ping

Describes functionality that is common to both standalone redis servers and redis clusters

Allows creation of a group of operations that will be sent to the server as a single unit, but which may or may not be processed on the server contiguously.

Allows creation of a group of operations that will be sent to the server as a single unit, and processed on the server as a single unit.

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

Decrements the number stored at field in the hash stored at key by decrement. 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 decrement operation. http://redis.io/commands/hincrby