StackExchange.Redis

Note that in results other than success, no guarantees are made about final state; if you care: snapshot

Represents a message that is broadcast via pub/sub

See Object.ToString

See Object.GetHashCode

See Object.Equals

The to compare.

The channel that the subscription was created from

The channel that the message was broadcast to

The value that was broadcast

Represents a message queue of ordered pub/sub notifications

To create a ChannelMessageQueue, use ISubscriber.Subscribe[Async](RedisKey)

The Channel that was subscribed for this queue

See Object.ToString

An awaitable task the indicates completion of the queue (including drain of data)

Consume a message from the channel.

The to use.

Attempt to synchronously consume a message from the channel.

The read from the Channel.

Attempt to query the backlog length of the queue.

The (approximate) count of items in the Channel.

Create a message loop that processes messages sequentially.

The handler to run when receiving a message.

Create a message loop that processes messages sequentially.

The handler to execute when receiving a message.

Stop receiving messages on this channel.

The flags to use when unsubscribing.

Stop receiving messages on this channel.

The flags to use when unsubscribing.

Represents the state of an individual client connection to redis

Address (host and port) of the client

total duration of the connection in seconds

current database ID

The flags associated with this connection

The client flags can be a combination of: A: connection to be closed ASAP b: the client is waiting in a blocking operation c: connection to be closed after writing entire reply d: a watched keys has been modified - EXEC will fail i: the client is waiting for a VM I/O (deprecated) M: the client is a master N: no specific flag set O: the client is a replica in MONITOR mode P: the client is a Pub/Sub subscriber r: the client is in readonly mode against a cluster node S: the client is a normal replica server U: the client is connected via a Unix domain socket x: the client is in a MULTI/EXEC context

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

an unique 64-bit client ID (introduced in Redis 2.8.12).

Format the object as a string

The class of the connection

Indicates a range of slots served by a cluster node

Create a new SlotRange value

The slot ID to start at. The slot ID to end at.

The start of the range (inclusive)

The end of the range (inclusive)

Indicates whether two ranges are not equal

The first slot range. The second slot range.

Indicates whether two ranges are equal.

The first slot range. The second slot range.

Try to parse a string as a range.

The range string to parse, e.g."1-12". The parsed , if successful.

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.

The other slot range to compare to.

See Object.Equals

The other slot range to compare to.

Indicates whether two ranges are equal

The other slot range to compare to.

See Object.GetHashCode()

See Object.ToString()

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

Gets all nodes contained in the configuration

The node that was asked for the configuration

Obtain the node relating to a specified endpoint

The endpoint to get a cluster node from.

Gets the node that serves the specified slot.

The slot ID to get a node by.

Gets the node that serves the specified key's slot.

The key to identify a node by.

Represents the configuration of a single node in a cluster configuration.

Gets all child nodes of the current node

Gets the endpoint of the current node

Gets whether this is the node which responded to the CLUSTER NODES request

Gets whether this node is a replica

Gets whether this node is flagged as noaddr

Gets the node's connection status

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

The to compare to.

See Object.Equals

The to compare to.

Indicates whether two ClusterNode instances are equivalent

The to compare to.

See object.GetHashCode()

See Object.ToString()

Represents the commands mapped on a particular configuration

The default commands specified by redis

The commands available to https://github.com/twitter/twemproxy

https://github.com/twitter/twemproxy/blob/master/notes/redis.md

The commands available to http://www.ideawu.com/ssdb/

http://www.ideawu.com/ssdb/docs/redis-to-ssdb.html

The commands available to https://redis.io/topics/sentinel

https://redis.io/topics/sentinel

Create a new CommandMap, customizing some commands

The commands to override.

Creates a CommandMap by specifying which commands are available or unavailable

The commands to specify. Whether the commands are available or excluded.

See Object.ToString()

Represents the information known about long-running commands

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.

Deduces a link to the redis documentation about the specified command

Describes a pre-condition used in a redis transaction

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

The key of the hash to check. The field in the hash to check. The value that the hash field must match.

Enforces that the given hash-field must exist.

The key of the hash to check. The field in the hash to check.

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

The key of the hash to check. The field in the hash to check. The value that the hash field must not match.

Enforces that the given hash-field must not exist.

The key of the hash to check. The field in the hash that must not exist.

Enforces that the given key must exist.

The key that must exist.

Enforces that the given key must not exist

The key that must not exist.

Enforces that the given list index must have the specified value

The key of the list to check. The position in the list to check. The value of the list position that must match.

Enforces that the given list index must exist

The key of the list to check. The position in the list that must exist.

Enforces that the given list index must not have the specified value

The key of the list to check. The position in the list to check. The value of the list position must not match.

Enforces that the given list index must not exist

The key of the list to check. The position in the list that must not exist.

Enforces that the given key must have the specified value

The key to check. The value that must match.

Enforces that the given key must not have the specified value

The key to check. The value that must not match.

Enforces that the given hash length is a certain value

The key of the hash to check. The length the hash must have.

Enforces that the given hash length is less than a certain value

The key of the hash to check. The length the hash must be less than.

Enforces that the given hash length is greater than a certain value

The key of the hash to check. The length the hash must be greater than.

Enforces that the given string length is a certain value

The key of the string to check. The length the string must be equal to.

Enforces that the given string length is less than a certain value

The key of the string to check. The length the string must be less than.

Enforces that the given string length is greater than a certain value

The key of the string to check. The length the string must be greater than.

Enforces that the given list length is a certain value

The key of the list to check. The length the list must be equal to.

Enforces that the given list length is less than a certain value

The key of the list to check. The length the list must be less than.

Enforces that the given list length is greater than a certain value

The key of the list to check. The length the list must be greater than.

Enforces that the given set cardinality is a certain value

The key of the set to check. The length the set must be equal to.

Enforces that the given set cardinality is less than a certain value

The key of the set to check. The length the set must be less than.

Enforces that the given set cardinality is greater than a certain value

The key of the set to check. The length the set must be greater than.

Enforces that the given set contains a certain member

The key of the set to check. The member the set must contain.

Enforces that the given set does not contain a certain member

The key of the set to check. The member the set must not contain.

Enforces that the given sorted set cardinality is a certain value

The key of the sorted set to check. The length the sorted set must be equal to.

Enforces that the given sorted set contains a certain number of members with scores in the given range

The key of the sorted set to check. The length the sorted set must be equal to. Minimum inclusive score. Maximum inclusive score.

Enforces that the given sorted set cardinality is less than a certain value

The key of the sorted set to check. The length the sorted set must be less than.

Enforces that the given sorted set contains less than a certain number of members with scores in the given range

The key of the sorted set to check. The length the sorted set must be equal to. Minimum inclusive score. Maximum inclusive score.

Enforces that the given sorted set cardinality is greater than a certain value

The key of the sorted set to check. The length the sorted set must be greater than.

Enforces that the given sorted set contains more than a certain number of members with scores in the given range

The key of the sorted set to check. The length the sorted set must be equal to. Minimum inclusive score. Maximum inclusive score.

Enforces that the given sorted set contains a certain member

The key of the sorted set to check. The member the sorted set must contain.

Enforces that the given sorted set does not contain a certain member

The key of the sorted set to check. The member the sorted set must not contain.

Enforces that the given sorted set member must have the specified score.

The key of the sorted set to check. The member the sorted set to check. The score that member must have.

Enforces that the given sorted set member must not have the specified score.

The key of the sorted set to check. The member the sorted set to check. The score that member must not have.

Enforces that the given sorted set must have the given score.

The key of the sorted set to check. The score that the sorted set must have.

Enforces that the given sorted set must not have the given score.

The key of the sorted set to check. The score that the sorted set must not have.

Enforces that the given sorted set must have the specified count of the given score.

The key of the sorted set to check. The score that the sorted set must have. The number of members which sorted set must have.

Enforces that the given sorted set must not have the specified count of the given score.

The key of the sorted set to check. The score that the sorted set must not have. The number of members which sorted set must not have.

Indicates the status of a condition as part of a transaction

Indicates whether the condition was satisfied

The options relevant to a set of redis connections

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

Specifies the time in milliseconds that the system should allow for asynchronous operations (defaults to SyncTimeout)

Indicates whether the connection should be encrypted

Automatically encodes and decodes channels

A Boolean value that specifies whether the certificate revocation list is checked during authentication.

Create a certificate validation check that checks against the supplied issuer even if not known by the machine

The file system path to find the certificate at.

Create a certificate validation check that checks against the supplied issuer even if not known by the machine

The issuer to trust.

The client name to use for all connections

The number of times to repeat the initial connect cycle if no servers respond promptly

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 (defaults to 5 seconds unless SyncTimeout is higher)

Specifies the default database to be used when calling ConnectionMultiplexer.GetDatabase() without any parameters

The server version to assume

The endpoints defined for this configuration

Use ThreadPriority.AboveNormal for SocketManager reader and writer threads (true by default). If false, ThreadPriority.Normal will be used.

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

The user to use to authenticate with the server.

The password to use to authenticate with the server.

Specifies whether asynchronous operations should be invoked in a way that guarantees their original delivery order

Type of proxy to use (if any); for example Proxy.Twemproxy.

The retry policy to be used for connection reconnects

Indicates whether endpoints should be resolved via DNS before connecting. If enabled the ConnectionMultiplexer will re-resolve DNS when attempting to re-connect after a connection failure.

Specifies the time in milliseconds that the system should allow for responses before concluding that the socket is unhealthy (defaults to SyncTimeout)

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 shared cross-multiplexer SocketManager is used

Indicates whether the connection should be encrypted

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

Configures which Ssl/TLS protocols should be allowed. If not set, defaults are chosen by the .NET framework.

Specifies the time in milliseconds that the system should allow for synchronous operations (defaults to 5 seconds)

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

The size of the output buffer to use

Check configuration every n seconds (every minute by default)

Parse the configuration from a comma-delimited configuration string

The configuration string to parse. is null. is empty.

Parse the configuration from a comma-delimited configuration string

The configuration string to parse. Whether to ignore unknown elements in . is null. is empty.

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, including Redis credentials.

Includes password to allow generation of configuration strings used for connecting multiplexer.

Returns the effective configuration string for this configuration with the option to include or exclude the password from the string.

Whether to include the password.

Illustrates the counters associated with an individual connection

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 replica

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

See Object.ToString()

Contains information about a server connection failure

This constructor is only for testing purposes.

The source of the event. Redis endpoint. Redis connection type. Redis connection failure type. The exception occured. Connection physical name.

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

Returns the physical name of the connection.

Represents an inter-related group of connections to redis servers

Enables or disables a feature flag; this should only be used under support guidance, and should not be rapidly toggled

Returns the state of a feature flag; this should only be used under support guidance

For debugging: when not enabled, servers cannot connect

For debugging: when not enabled, end-connect is silently ignored (to simulate a long-running connect)

Tracks overall connection multiplexer counts

Provides a way of overriding the default Task Factory. If not set, it will use the default Task.Factory. Useful when top level code sets it's own factory which may interfere with Redis queries.

Get summary statistics associates with this server

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

Tries to get the Roleinstance Id if Microsoft.WindowsAzure.ServiceRuntime is loaded. In case of any failure, swallows the exception and returns null

Gets the configuration of the connection

A server replied with an error message;

Write the configuration of all servers to an output stream

The destination stream to write the export to. The options to use for this export.

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/replica changes

Gets the synchronous timeout associated with the connections

Gets the asynchronous timeout associated with the connections

Gets all endpoints defined on the server

Whether to get only the endpoints specified explicitly in the config.

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

The task to wait on.

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

The type contains in the task to wait on. The task to wait on.

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

The tasks to wait on.

Raised when a hash-slot has been relocated

Compute the hash-slot of a specified key

The key to get a hash slot ID for.

Create a new ConnectionMultiplexer instance

The string configuration to use for this multiplexer. The to log to.

Create a new ConnectionMultiplexer instance

The configuration options to use for this multiplexer. The to log to.

Create a new ConnectionMultiplexer instance

The string configuration to use for this multiplexer. The to log to.

Create a new ConnectionMultiplexer instance

The configuration options to use for this multiplexer. The to log to.

Create a new ConnectionMultiplexer instance that connects to a sentinel server

The string configuration to use for this multiplexer. The to log to.

Create a new ConnectionMultiplexer instance that connects to a sentinel server

The string configuration to use for this multiplexer. The to log to.

Create a new ConnectionMultiplexer instance that connects to a sentinel server

The configuration options to use for this multiplexer. The to log to.

Create a new ConnectionMultiplexer instance that connects to a sentinel server

The configuration options to use for this multiplexer. The to log to.

Create a new ConnectionMultiplexer instance that connects to a sentinel server, discovers the current master server for the specified ServiceName in the config and returns a managed connection to the current master server

The string configuration to use for this multiplexer. The to log to.

The configuration options to use for this multiplexer. The to log to.

The string configuration to use for this multiplexer. The to log to.

The configuration options to use for this multiplexer. The to log to.

Obtain a pub/sub subscriber connection to the specified server

The async state object to pass to the created .

Obtain an interactive connection to a database inside redis

The ID to get a database for. The async state to pass into the resulting .

Obtain a configuration API for an individual server

The host to get a server for. The port for to get a server for. The async state to pass into the resulting .

Obtain a configuration API for an individual server

The "host:port" string to get a server for. The async state to pass into the resulting .

Obtain a configuration API for an individual server

The host to get a server for. The port for to get a server for.

Obtain a configuration API for an individual server

The endpoint to get a server for. The async state to pass into the resulting .

The number of operations that have been performed on all connections

Reconfigure the current connections based on the existing configuration

The to log to.

Reconfigure the current connections based on the existing configuration

The to log to.

Provides a text overview of the status of all connections

The to log to.

See Object.ToString()

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

Indicates whether any servers are connected

Indicates whether any servers are currently trying to connect

Initializes the connection as a Sentinel connection and adds the necessary event handlers to track changes to the managed masters.

Returns a managed connection to the master server indicated by the ServiceName in the config.

the configuration to be used when connecting to the master

Switches the SentinelMasterConnection over to a new master.

The endpoint responsible for the switch The connection that should be switched over to a new master endpoint Log to write to, if any

Close all connections and release all resources associated with this object

Whether to allow all in-queue commands to complete first.

Close all connections and release all resources associated with this object

Whether to allow all in-queue commands to complete first.

Release all resources associated with this object

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

Should exceptions include performance counter details? (CPU usage, etc - note that this can be problematic on some platforms)

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)

Obtains the log of unusual busy patterns

Resets the log of unusual busy patterns

Request all compatible clients to reconfigure or reconnect

The command flags to use.2 The number of instances known to have received the message (however, the actual number can be higher; returns -1 if the operation is pending)

Request all compatible clients to reconfigure or reconnect

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

Get the hash-slot associated with a given key, if applicable; this can be useful for grouping operations

The to determine the hash slot for.

Register a callback to provide an on-demand ambient session provider based on the calling context; the implementing code is responsible for reliably resolving the same provider based on ambient context, or returning null to not profile

The session provider to register.

Provides the ability to iterate over a cursor-based sequence of redis data, synchronously or asynchronously

Gets an enumerator for the sequence

Provides the ability to iterate over a cursor-based sequence of redis data, synchronously or asynchronously

Gets the current value of the enumerator

Release all resources associated with this enumerator

Try to move to the next item in the sequence

Reset the enumerator

A list of endpoints

Create a new EndPointCollection

The endpoints to add to the collection.

Format an endpoint

The endpoint to get a string representation for.

Attempt to parse a string into an EndPoint

The endpoint string to parse.

Adds a new endpoint to the list

The host:port string to add an endpoint for to the collection.

Adds a new endpoint to the list.

The host to add. The port for to add.

Adds a new endpoint to the list.

The host to add. The port for to add.

Try adding a new endpoint to the list.

The endpoint to add. True if the endpoint was added or false if not.

See Collection<T>.InsertItem()

The index to add into the collection at. The item to insert at .

See Collection<T>.SetItem()

The index to replace an endpoint at. The item to replace the existing endpoint at .

Event information related to redis endpoints

This constructor is only for testing purposes.

The source of the event. Redis endpoint.

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

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

Bitwise operators

And

Xor

Not

The client flags can be a combination of: O: the client is a replica in MONITOR mode S: the client is a normal replica 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 replica in MONITOR mode

the client is a normal replica 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

the client is a Pub/Sub subscriber

the client is in readonly mode against a cluster node

the client is connected via a Unix domain socket

The class of the connection

Regular connections, including MONITOR connections

Replication connections

Subscription connections

Behaviour markers associated with a given command

Default behaviour.

From 2.0, this flag is not used

The caller is not interested in the result; the caller will immediately receive a default-value of the expected return type (this value is not indicative of anything at the server).

This operation should be performed on the master if it is available, but read operations may be performed on a replica if no master is available. This is the default option.

This operation should only be performed on the master.

This operation should be performed on the replica if it is available, but will be performed on a master if no replicas are available. Suitable for read operations only.

This operation should only be performed on a replica. Suitable for read operations only.

Indicates that this operation should not be forwarded to other servers as a result of an ASK or MOVED response

Indicates that script-related operations should use EVAL, not SCRIPT LOAD + EVALSHA

track status of a command while communicating with Redis

command status unknown

ConnectionMultiplexer has not yet started writing this command to redis

command has been sent to Redis

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

Either SSL Stream or Redis authentication failed

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)

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

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

Units associated with Geo Commands

Meters

Kilometers

Miles

Feet

Additional options for the MIGRATE command

No options specified

Do not remove the key from the local instance.

Replace existing key on the remote instance.

The direction in which to sequence elements

Ordered from low values to high values

Ordered from high values to low values

Specifies the proxy that is being used to communicate to redis

Direct communication to the redis server(s)

Communication via twemproxy

The intrinsinc data-types supported by redis

https://redis.io/topics/data-types

The specified key does not exist

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. A String value can be at max 512 Megabytes in length.

https://redis.io/commands#string

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.

https://redis.io/commands#list

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). Redis Sets have the desirable property of not allowing repeated members. Adding the same element multiple times will result in a set having a single copy of this element. Practically speaking this means that adding a member does not require a check if exists then add operation.

https://redis.io/commands#set

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. While members are unique, scores may be repeated.

https://redis.io/commands#sorted_set

Redis Hashes are maps between string fields and string values, so they are the perfect data type to represent objects (eg: A User with a number of fields like name, surname, age, and so forth)

https://redis.io/commands#hash

A Redis Stream is a data structure which models the behavior of an append only log but it has more advanced features for manipulating the data contained within the stream. Each entry in a stream contains a unique message ID and a list of name/value pairs containing the entry's data.

https://redis.io/commands#stream

The data-type was not recognised by the client library

Additional operations to perform when making a server a master

No additional operations

Set the tie-breaker key on all available masters, to specify this server

Broadcast to the pub-sub channel to listening clients to reconfigure themselves

Issue a REPLICAOF to all other known nodes, making this this master of all

All additional operations

The underlying result type as defined by redis

No value was received

Basic strings typically represent status results such as "OK"

Error strings represent invalid operation results from the server

Integers are returned for count operations and some integer-based increment operations

Bulk strings represent typical user content values

Multi-bulk replies represent complex results such as arrays

If an IProfiledCommand is a retransmission of a previous command, this enum is used to indicate what prompted the retransmission. This can be used to distinguish between transient causes (moving hashslots, joining nodes, etc.) and incorrect routing.

No stated reason

Issued to investigate which node owns a key

A node has indicated that it does *not* own the given key

The type of save operation to perform

Instruct Redis to start an Append Only File rewrite process. The rewrite will create a small optimized version of the current Append Only File.

https://redis.io/commands/bgrewriteaof

Save the DB in background. The OK code is immediately returned. Redis forks, the parent continues to serve the clients, the child saves the DB on disk then exits. A client my be able to check if the operation succeeded using the LASTSAVE command.

https://redis.io/commands/bgsave

Save the DB in foreground. This is almost never a good thing to do, and could cause significant blocking. Only do this if you know you need to save

https://redis.io/commands/save

Indicates the flavor of a particular redis server

Classic redis-server server

Monitoring/configuration redis-sentinel server

Distributed redis-cluster server

Distributed redis installation via twemproxy

Describes an algebraic set operation that can be performed to combine multiple sets

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

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

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

Defines the persistence behaviour of the server during shutdown

The data is persisted if save points are configured

The data is NOT persisted even if save points are configured

The data is persisted even if save points are NOT configured

Specifies how to compare elements for sorting

Elements are interpreted as a double-precision floating point number and sorted numerically

Elements are sorted using their alphabetic form (Redis is UTF-8 aware as long as the !LC_COLLATE environment variable is set at the server)

Indicates when this operation should be performed (only some variations are legal in a given context)

The operation should occur whether or not there is an existing value

The operation should only occur when there is an existing value

The operation should only occur when there is not an existing value

Indicates that a command was illegal and was not sent to the server

Creates a new .

The message for the exception.

Creates a new .

The message for the exception. The inner exception.

Indicates the time allotted for a command or operation has expired.

Creates a new .

The message for the exception. The command status, as of when the timeout happened.

status of the command while communicating with Redis

Serialization implementation; not intended for general usage

Serialization info. Serialization context.

Indicates a connection fault when communicating with redis

Creates a new .

The type of connection failure. The message for the exception.

Creates a new .

The type of connection failure. The message for the exception. The inner exception.

Creates a new .

The type of connection failure. The message for the exception. The inner exception. The status of the command.

The type of connection failure

status of the command while communicating with Redis

Serialization implementation; not intended for general usage

Serialization info. Serialization context.

Indicates an issue communicating with redis

Creates a new .

The message for the exception.

Creates a new .

The message for the exception. The inner exception.

Deserialization constructor; not intended for general usage

Serialization info. Serialization context.

Indicates an exception raised by a redis server

Creates a new .

The message for the exception.

Represents a retry policy that performs retries, using a randomized exponential back off scheme to determine the interval between retries.

Initializes a new instance using the specified back off interval with default maxDeltaBackOffMilliseconds of 10 seconds

time in milliseconds for the back-off interval between retries

Initializes a new instance using the specified back off interval.

time in milliseconds for the back-off interval between retries time in milliseconds for the maximum value that the back-off interval can exponentailly grow upto

This method is called by the ConnectionMultiplexer to determine if a reconnect operation can be retried now.

The number of times reconnect retries have already been made by the ConnectionMultiplexer while it was in the connecting state Total elapsed time in milliseconds since the last reconnect retry was made

Utility methods

Create a dictionary from an array of HashEntry values

The entry to convert to a dictionary.

Create a dictionary from an array of HashEntry values

The entry to convert to a dictionary.

Create a dictionary from an array of SortedSetEntry values

The set entries to convert to a dictionary.

Create a dictionary from an array of SortedSetEntry values

The set entries to convert to a dictionary.

Create a dictionary from an array of key/value pairs

The pairs to convert to a dictionary.

Create a dictionary from an array of key/value pairs

The pairs to convert to a dictionary.

Create a dictionary from an array of string pairs

The pairs to convert to a dictionary.

Create an array of RedisValues from an array of strings.

The string array to convert to RedisValues

Create an array of strings from an array of values

The values to convert to an array.

Represent a byte-Lease as a read-only Stream

The lease upon which to base the stream If true, disposing the stream also disposes the lease

Decode a byte-Lease as a String, optionally specifying the encoding (UTF-8 if omitted)

The bytes to decode The encoding to use

Decode a byte-Lease as a String, optionally specifying the encoding (UTF-8 if omitted)

The bytes to decode The encoding to use

GeoRadius command options.

No Options

Redis will return the coordinates of any results.

Redis will return the distance from center for all results.

Redis will return the geo hash value as an integer. (This is the score in the sorted set)

Populates the commonly used values from the entry (the integer hash is not returned as it is not commonly useful)

The result of a GeoRadius command.

Indicate the member being represented

The matched member.

The distance of the matched member from the center of the geo radius command.

The hash value of the matched member as an integer. (The key in the sorted set)

Note that this is not the same as the hash returned from GeoHash

The coordinates of the matched member.

Returns a new GeoRadiusResult

The value from the result. Tthe distance from the result. The hash of the result. The geo position of the result.

Describes the longitude and latitude of a GeoEntry

The Latitude of the GeoPosition

The Logitude of the GeoPosition

Creates a new GeoPosition

See Object.ToString()

See Object.GetHashCode() Diagonals not an issue in the case of lat/long

Diagonals are not an issue in the case of lat/long.

Compares two values for equality

The to compare to.

Compares two values for equality

The to compare to.

Compares two values for equality

The first position to compare. The second position to compare.

Compares two values for non-equality

The first position to compare. The second position to compare.

Describes a GeoEntry element with the corresponding value GeoEntries are stored in redis as SortedSetEntries

The name of the geo entry

Describes the longitude and latitude of a GeoEntry

Initializes a GeoEntry value

The longitude position to use. The latitude position to use. The value to store for this position.

The longitude of the geo entry

The latitude of the geo entry

See Object.ToString()

See Object.GetHashCode()

Compares two values for equality

The to compare to.

Compares two values for equality

The to compare to.

Compares two values for equality

The first entry to compare. The second entry to compare.

Compares two values for non-equality

The first entry to compare. The second entry to compare.

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

Initializes a value.

The name for this hash entry. The value for this hash entry.

The name of the hash field

The value of the hash field

The name of the hash field

Converts to a key/value pair

The to create a from.

Converts from a key/value pair

The to get a from.

See Object.ToString()

See Object.GetHashCode()

Compares two values for equality.

The to compare to.

Compares two values for equality.

The to compare to.

Compares two values for equality

The first to compare. The second to compare.

Compares two values for non-equality

The first to compare. The second to compare.

Contains information about individual hash-slot relocations

The hash-slot that was relocated

The old endpoint for this hash-slot (if known)

The new endpoint for this hash-slot (if known)

This constructor is only for testing purposes.

The source of the event. Hash slot. Old endpoint. New endpoint.

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.

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.

Represents the abstract multiplexer API

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

Gets the configuration of the connection

Gets the timeout associated with the connections

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 profiling session provider.

Get summary statistics associates with this server

A server replied with an error message;

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/replica changes

Gets all endpoints defined on the server

Whether to return only the explicitly configured endpoints.

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

The task to wait on.

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

The type in . The task to wait on.

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

The tasks to wait on.

Raised when a hash-slot has been relocated

Compute the hash-slot of a specified key

The key to get a slot ID for.

Obtain a pub/sub subscriber connection to the specified server

The async state to pass to the created .

Obtain an interactive connection to a database inside redis

The database ID to get. The async state to pass to the created .

Obtain a configuration API for an individual server

The host to get a server for. The specific port for to get a server for. The async state to pass to the created .

Obtain a configuration API for an individual server

The "host:port" string to get a server for. The async state to pass to the created .

Obtain a configuration API for an individual server

The host to get a server for. The specific port for to get a server for.

Obtain a configuration API for an individual server

The endpoint to get a server for. The async state to pass to the created .

Reconfigure the current connections based on the existing configuration

The log to write output to.

Reconfigure the current connections based on the existing configuration

The log to write output to.

Provides a text overview of the status of all connections

The log to write output to.

See Object.ToString()

Close all connections and release all resources associated with this object

Whether to allow in-queue commadns to complete first.

Close all connections and release all resources associated with this object

Whether to allow in-queue commadns to complete first.

Obtains the log of unusual busy patterns

Resets the log of unusual busy patterns

Request all compatible clients to reconfigure or reconnect

The command flags to use. The number of instances known to have received the message (however, the actual number can be higher; returns -1 if the operation is pending)

Request all compatible clients to reconfigure or reconnect

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

Get the hash-slot associated with a given key, if applicable; this can be useful for grouping operations

The key to get a the slot for.

Write the configuration of all servers to an output stream

The destination stream to write the export to. The options to use for this export.

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

The numeric identifier of this database

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.

The async object state to be passed into the created . The created batch.

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.

The async object state to be passed into the created . The created transaction.

Atomically transfer a key from a source Redis instance to a destination Redis instance. On success the key is deleted from the original instance by default, and is guaranteed to exist in the target instance.

The key to migrate. The server to migrate the key to. The database to migrate the key to. The timeout to use for the transfer. The options to use for this migration. The flags to use for this operation. https://redis.io/commands/MIGRATE

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.

The key to debug. The flags to use for this migration. The raw output from DEBUG OBJECT. https://redis.io/commands/debug-object

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.

The key of the set. The longitude of geo entry. The latitude of the geo entry. The value to set at this entry. The flags to use for this operation. True if the specified member was not already present in the set, else False. https://redis.io/commands/geoadd

The key of the set. The geo value to store. The flags to use for this operation. True if the specified member was not already present in the set, else False https://redis.io/commands/geoadd

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 key of the set. The geo values add to the set. The flags to use for this operation. The number of elements that were added to the set, not including all the elements already present into the set. https://redis.io/commands/geoadd

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

The key of the set. The geo value to remove. The flags to use for this operation. True if the member existed in the sorted set and was removed; False otherwise. https://redis.io/commands/zrem

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

The key of the set. The first member to check. The second member to check. The unit of distance to return (defaults to meters). The flags to use for this operation. The command returns the distance as a double (represented as a string) in the specified unit, or NULL if one or both the elements are missing. https://redis.io/commands/geodist

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

The key of the set. The members to get. The flags to use for this operation. The command returns an array where each element is the Geohash corresponding to each member name passed as argument to the command. https://redis.io/commands/geohash

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

The key of the set. The member to get. The flags to use for this operation. The command returns an array where each element is the Geohash corresponding to each member name passed as argument to the command. https://redis.io/commands/geohash

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

The key of the set. The members to get. The flags to use for this operation. The command returns an array where each element is a two elements array representing longitude and latitude (x,y) of each member name passed as argument to the command.Non existing elements are reported as NULL elements of the array. https://redis.io/commands/geopos

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

The key of the set. The member to get. The flags to use for this operation. The command returns an array where each element is a two elements array representing longitude and latitude (x,y) of each member name passed as argument to the command.Non existing elements are reported as NULL elements of the array. https://redis.io/commands/geopos

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

The key of the set. The member to get a radius of results from. The radius to check. The unit of (defaults to meters). The count of results to get, -1 for unlimited. The order of the results. The search options to use. The flags to use for this operation. The results found within the radius, if any. https://redis.io/commands/georadius

The key of the set. The longitude of the point to get a radius of results from. The latitude of the point to get a radius of results from. The radius to check. The unit of (defaults to meters). The count of results to get, -1 for unlimited. The order of the results. The search options to use. The flags to use for this operation. The results found within the radius, if any. https://redis.io/commands/georadius

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 key of the hash. The field in the hash to decrement. The amount to decrement by. The flags to use for this operation. The value at field after the decrement operation. The range of values supported by HINCRBY is limited to 64 bit signed integers. https://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 key of the hash. The field in the hash to decrement. The amount to decrement by. The flags to use for this operation. The value at field after the decrement operation. The precision of the output is fixed at 17 digits after the decimal point regardless of the actual internal precision of the computation. https://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.

The key of the hash. The field in the hash to delete. The flags to use for this operation. The number of fields that were removed. https://redis.io/commands/hdel

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.

The key of the hash. The fields in the hash to delete. The flags to use for this operation. The number of fields that were removed. https://redis.io/commands/hdel

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

The key of the hash. The field in the hash to check. The flags to use for this operation. 1 if the hash contains field. 0 if the hash does not contain field, or key does not exist. https://redis.io/commands/hexists

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

The key of the hash. The field in the hash to get. The flags to use for this operation. The value associated with field, or nil when field is not present in the hash or key does not exist. https://redis.io/commands/hget

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

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.

The key of the hash. The fields in the hash to delete. The flags to use for this operation. List of values associated with the given fields, in the same order as they are requested. https://redis.io/commands/hmget

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

The key of the hash to get all entries from. The flags to use for this operation. List of fields and their values stored in the hash, or an empty list when key does not exist. https://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 key of the hash. The field in the hash to increment. The amount to increment by. The flags to use for this operation. The value at field after the increment operation. The range of values supported by HINCRBY is limited to 64 bit signed integers. https://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 key of the hash. The field in the hash to increment. The amount to increment by. The flags to use for this operation. The value at field after the increment operation. The precision of the output is fixed at 17 digits after the decimal point regardless of the actual internal precision of the computation. https://redis.io/commands/hincrbyfloat

Returns all field names in the hash stored at key.

The key of the hash. The flags to use for this operation. List of fields in the hash, or an empty list when key does not exist. https://redis.io/commands/hkeys

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

The key of the hash. The flags to use for this operation. The number of fields in the hash, or 0 when key does not exist. https://redis.io/commands/hlen

The HSCAN command is used to incrementally iterate over a hash.

The key of the hash. The pattern of keys to get entries for. The page size to iterate by. The flags to use for this operation. Yields all elements of the hash matching the pattern. https://redis.io/commands/hscan

The HSCAN command is used to incrementally iterate over a hash; note: to resume an iteration via cursor, cast the original enumerable or enumerator to IScanningCursor.

The key of the hash. The pattern of keys to get entries for. The page size to iterate by. The cursor position to start at. The page offset to start at. The flags to use for this operation. Yields all elements of the hash matching the pattern. https://redis.io/commands/hscan

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

The key of the hash. The entries to set in the hash. The flags to use for this operation. https://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.

The key of the hash. The field to set in the hash. The value to set. Which conditions under which to set the field value (defaults to always). The flags to use for this operation. 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. https://redis.io/commands/hset https://redis.io/commands/hsetnx

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

The key of the hash. The field containing the string The flags to use for this operation. the length of the string at field, or 0 when key does not exist. https://redis.io/commands/hstrlen

Returns all values in the hash stored at key.

The key of the hash. The flags to use for this operation. List of values in the hash, or an empty list when key does not exist. https://redis.io/commands/hvals

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

The key of the hyperloglog. The value to add. The flags to use for this operation. True if at least 1 HyperLogLog internal register was altered, false otherwise. https://redis.io/commands/pfadd

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

The key of the hyperloglog. The values to add. The flags to use for this operation. True if at least 1 HyperLogLog internal register was altered, false otherwise. https://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 key of the hyperloglog. The flags to use for this operation. The approximated number of unique elements observed via HyperLogLogAdd. https://redis.io/commands/pfcount

Returns the approximated cardinality of the union of the HyperLogLogs passed, by internally merging the HyperLogLogs stored at the provided keys into a temporary hyperLogLog, or 0 if the variable does not exist.

The keys of the hyperloglogs. The flags to use for this operation. The approximated number of unique elements observed via HyperLogLogAdd. https://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.

The key of the merged hyperloglog. The key of the first hyperloglog to merge. The key of the first hyperloglog to merge. The flags to use for this operation. https://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.

The key of the merged hyperloglog. The keys of the hyperloglogs to merge. The flags to use for this operation. https://redis.io/commands/pfmerge

Inidicate exactly which redis server we are talking to.

The key to check. The flags to use for this operation. The endpoint serving the key.

Removes the specified key. A key is ignored if it does not exist. If UNLINK is available (Redis 4.0+), it will be used.

The key to delete. The flags to use for this operation. True if the key was removed. https://redis.io/commands/del https://redis.io/commands/unlink

Removes the specified keys. A key is ignored if it does not exist. If UNLINK is available (Redis 4.0+), it will be used.

The keys to delete. The flags to use for this operation. The number of keys that were removed. https://redis.io/commands/del https://redis.io/commands/unlink

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 key to dump. The flags to use for this operation. the serialized value. https://redis.io/commands/dump

Returns if key exists.

The key to check. The flags to use for this operation. 1 if the key exists. 0 if the key does not exist. https://redis.io/commands/exists

Indicates how many of the supplied keys exists.

The keys to check. The flags to use for this operation. The number of keys that existed. https://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.

The key to set the expiration for. The timeout to set. The flags to use for this operation. 1 if the timeout was set. 0 if key does not exist or the timeout could not be set. 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. https://redis.io/commands/expire https://redis.io/commands/pexpire https://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.

The key to set the expiration for. The exact date to expiry to set. The flags to use for this operation. 1 if the timeout was set. 0 if key does not exist or the timeout could not be set. 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. https://redis.io/commands/expireat https://redis.io/commands/pexpireat https://redis.io/commands/persist

Returns the time since the object stored at the specified key is idle (not requested by read or write operations)

The key to get the time of. The flags to use for this operation. The time since the object stored at the specified key is idle https://redis.io/commands/object

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.

The key to move. The database to move the key to. The flags to use for this operation. 1 if key was moved; 0 if key was not moved. https://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).

The key to presist. The flags to use for this operation. 1 if the timeout was removed. 0 if key does not exist or does not have an associated timeout. https://redis.io/commands/persist

Return a random key from the currently selected database.

The flags to use for this operation. The random key, or nil when the database is empty. https://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.

The key to rename. The key to rename to. What conditions to rename under (defaults to always). The flags to use for this operation. True if the key was renamed, false otherwise. https://redis.io/commands/rename https://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.

The key to restore. The value of the key. The expiry to set. The flags to use for this operation. https://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.

The key to check. The flags to use for this operation. TTL, or nil when key does not exist or does not have a timeout. https://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.

The key to get the type of. The flags to use for this operation. Type of key, or none when key does not exist. https://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 key of the list. The index position to ge the value at. The flags to use for this operation. The requested element, or nil when index is out of range. https://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 key of the list. The value to insert after. The value to insert. The flags to use for this operation. The length of the list after the insert operation, or -1 when the value pivot was not found. https://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 key of the list. The value to insert before. The value to insert. The flags to use for this operation. The length of the list after the insert operation, or -1 when the value pivot was not found. https://redis.io/commands/linsert

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

The key of the list. The flags to use for this operation. The value of the first element, or nil when key does not exist. https://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 key of the list. The value to add to the head of the list. Which conditions to add to the list under (defaults to always). The flags to use for this operation. The length of the list after the push operations. https://redis.io/commands/lpush https://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 key of the list. The values to add to the head of the list. The flags to use for this operation. The length of the list after the push operations. https://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 key of the list. The flags to use for this operation. The length of the list at key. https://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.

The key of the list. The start index of the list. The stop index of the list. The flags to use for this operation. List of elements in the specified range. https://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 key of the list. The value to remove from the list. The count behavior (see method summary). The flags to use for this operation. The number of removed elements. https://redis.io/commands/lrem

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

The key of the list. The flags to use for this operation. The element being popped. https://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 key of the source list. The key of the destination list. The flags to use for this operation. The element being popped and pushed. https://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 key of the list. The value to add to the tail of the list. Which conditions to add to the list under. The flags to use for this operation. The length of the list after the push operation. https://redis.io/commands/rpush https://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 key of the list. The values to add to the tail of the list. The flags to use for this operation. The length of the list after the push operation. https://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.

The key of the list. The index to set the value at. The values to add to the list. The flags to use for this operation. https://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.

The key of the list. The start index of the list to trim to. The end index of the list to trim to. The flags to use for this operation. https://redis.io/commands/ltrim

Extends a lock, if the token value is correct.

The key of the lock. The value to set at the key. The expiration of the lock key. The flags to use for this operation. True if the lock was successfully extended.

Queries the token held against a lock.

The key of the lock. The flags to use for this operation. The current value of the lock, if any.

Releases a lock, if the token value is correct.

The key of the lock. The value at the key tht must match. The flags to use for this operation. True if the lock was successfully released, false otherwise.

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

The key of the lock. The value to set at the key. The expiration of the lock key. The flags to use for this operation. True if the lock was successfully taken, false otherwise.

Posts a message to the given channel.

The channel to publish to. The message to send. The flags to use for this operation. The number of clients that received the message. https://redis.io/commands/publish

Execute an arbitrary command against the server; this is primarily intended for executing modules, but may also be used to provide access to new features that lack a direct API.

The command to run. The arguments to pass for the command. This API should be considered an advanced feature; inappropriate use can be harmful A dynamic representation of the command's result

Execute an arbitrary command against the server; this is primarily intended for executing modules, but may also be used to provide access to new features that lack a direct API.

The command to run. The arguments to pass for the command. The flags to use for this operation. This API should be considered an advanced feature; inappropriate use can be harmful A dynamic representation of the command's result

Execute a Lua script against the server.

The script to execute. The keys to execute against. The values to execute against. The flags to use for this operation. A dynamic representation of the script's result https://redis.io/commands/eval https://redis.io/commands/evalsha

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

The hash of the script to execute. The keys to execute against. The values to execute against. The flags to use for this operation. A dynamic representation of the script's result https://redis.io/commands/evalsha

Execute a lua script against the server, using previously prepared script. Named parameters, if any, are provided by the `parameters` object.

The script to execute. The parameters to pass to the script. The flags to use for this operation. A dynamic representation of the script's result https://redis.io/commands/eval

Execute a lua script against the server, using previously prepared and loaded script. This method sends only the SHA1 hash of the lua script to Redis. Named parameters, if any, are provided by the `parameters` object.

The already-loaded script to execute. The parameters to pass to the script. The flags to use for this operation. A dynamic representation of the script's result https://redis.io/commands/eval

The key of the set. The value to add to the set. The flags to use for this operation. True if the specified member was not already present in the set, else False https://redis.io/commands/sadd

The key of the set. The values to add to the set. The flags to use for this operation. The number of elements that were added to the set, not including all the elements already present into the set. https://redis.io/commands/sadd

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

The operation to perform. The key of the first set. The key of the second set. The flags to use for this operation. List with members of the resulting set. https://redis.io/commands/sunion https://redis.io/commands/sinter https://redis.io/commands/sdiff

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

The operation to perform. The keys of the sets to operate on. The flags to use for this operation. List with members of the resulting set. https://redis.io/commands/sunion https://redis.io/commands/sinter https://redis.io/commands/sdiff

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 operation to perform. The key of the destination set. The key of the first set. The key of the second set. The flags to use for this operation. The number of elements in the resulting set. https://redis.io/commands/sunionstore https://redis.io/commands/sinterstore https://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 operation to perform. The key of the destination set. The keys of the sets to operate on. The flags to use for this operation. The number of elements in the resulting set. https://redis.io/commands/sunionstore https://redis.io/commands/sinterstore https://redis.io/commands/sdiffstore

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

The key of the set. The value to check for . The flags to use for this operation. 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. https://redis.io/commands/sismember

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

The key of the set. The flags to use for this operation. The cardinality (number of elements) of the set, or 0 if key does not exist. https://redis.io/commands/scard

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

The key of the set. The flags to use for this operation. All elements of the set. https://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.

The key of the source set. The key of the destination set. The value to move. The flags to use for this operation. 1 if the element is moved. 0 if the element is not a member of source and no operation was performed. https://redis.io/commands/smove

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

The key of the set. The flags to use for this operation. The removed element, or nil when key does not exist. https://redis.io/commands/spop

Removes and returns the specified number of random elements from the set value stored at key.

The key of the set. The number of elements to return. The flags to use for this operation. An array of elements, or an empty array when key does not exist. https://redis.io/commands/spop

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

The key of the set. The flags to use for this operation. The randomly selected element, or nil when key does not exist https://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 key of the set. The count of members to get. The flags to use for this operation. An array of elements, or an empty array when key does not exist https://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.

The key of the set. The value to remove. The flags to use for this operation. True if the specified member was already present in the set, else False https://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 key of the set. The values to remove. The flags to use for this operation. The number of members that were removed from the set, not including non existing members. https://redis.io/commands/srem

The SSCAN command is used to incrementally iterate over set

The key of the set. The pattern to match. The page size to iterate by. The flags to use for this operation. Yields all matching elements of the set. https://redis.io/commands/sscan

The SSCAN command is used to incrementally iterate over set; note: to resume an iteration via cursor, cast the original enumerable or enumerator to IScanningCursor.

The key of the set. The pattern to match. The page size to iterate by. The cursor position to start at. The page offset to start at. The flags to use for this operation. Yields all matching elements of the set. https://redis.io/commands/sscan

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

The key of the list, set, or sorted set. How many entries to skip on the return. How many entries to take on the return. The ascending or descending order (defaults to ascending). The sorting method (defaults to numeric). The key pattern to sort by, if any. e.g. ExternalKey_* would sort by ExternalKey_{listvalue} as a lookup. The key pattern to sort by, if any e.g. ExternalKey_* would return the value of ExternalKey_{listvalue} for each entry. The flags to use for this operation. The sorted elements, or the external values if get is specified. https://redis.io/commands/sort

The destination key to store results in. The key of the list, set, or sorted set. How many entries to skip on the return. How many entries to take on the return. The ascending or descending order (defaults to ascending). The sorting method (defaults to numeric). The key pattern to sort by, if any. e.g. ExternalKey_* would sort by ExternalKey_{listvalue} as a lookup. The key pattern to sort by, if any e.g. ExternalKey_* would return the value of ExternalKey_{listvalue} for each entry. The flags to use for this operation. The number of elements stored in the new list. https://redis.io/commands/sort

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.

The key of the sorted set. The member to add to the sorted set. The score for the member to add to the sorted set. The flags to use for this operation. True if the value was added, False if it already existed (the score is still updated) https://redis.io/commands/zadd

The key of the sorted set. The member to add to the sorted set. The score for the member to add to the sorted set. What conditions to add the element under (defaults to always). The flags to use for this operation. True if the value was added, False if it already existed (the score is still updated) https://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 key of the sorted set. The members and vlues to add to the sorted set. The flags to use for this operation. The number of elements added to the sorted sets, not including elements already existing for which the score was updated. https://redis.io/commands/zadd

The key of the sorted set. The members and vlues to add to the sorted set. What conditions to add the element under (defaults to always). The flags to use for this operation. The number of elements added to the sorted sets, not including elements already existing for which the score was updated. https://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).

The operation to perform. The key to store the results in. The key of the first sorted set. The key of the second sorted set. The aggregation method (defaults to sum). The flags to use for this operation. https://redis.io/commands/zunionstore https://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).

The operation to perform. The key to store the results in. The keys of the sorted sets. The optional weights per set that correspond to . The aggregation method (defaults to sum). The flags to use for this operation. https://redis.io/commands/zunionstore https://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 key of the sorted set. The member to decrement. The amount to decrement by. The flags to use for this operation. The new score of member. https://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 key of the sorted set. The member to increment. The amount to increment by. The flags to use for this operation. The new score of member. https://redis.io/commands/zincrby

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

The key of the sorted set. The min score to filter by (defaults to negative infinity). The max score to filter by (defaults to positive infinity). Whether to exclude and from the range check (defaults to both inclusive). The flags to use for this operation. The cardinality (number of elements) of the sorted set, or 0 if key does not exist. https://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 key of the sorted set. The min value to filter by. The max value to filter by. Whether to exclude and from the range check (defaults to both inclusive). The flags to use for this operation. The number of elements in the specified score range. https://redis.io/commands/zlexcount

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.

The key of the sorted set. The start index to get. The stop index to get. The order to sort by (defaults to ascending). The flags to use for this operation. List of elements in the specified range. https://redis.io/commands/zrange https://redis.io/commands/zrevrange

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. Start and stop are used to specify the min and max range for score values. Similar to other range methods the values are inclusive.

The key of the sorted set. The minimum score to filter by. The maximum score to filter by. Which of and to exclude (defaults to both inclusive). The order to sort by (defaults to ascending). How many items to skip. How many items to take. The flags to use for this operation. List of elements in the specified score range. https://redis.io/commands/zrangebyscore https://redis.io/commands/zrevrangebyscore

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. Start and stop are used to specify the min and max range for score values. Similar to other range methods the values are inclusive.

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.

The key of the sorted set. The min value to filter by. The max value to filter by. Which of and to exclude (defaults to both inclusive). How many items to skip. How many items to take. The flags to use for this operation. https://redis.io/commands/zrangebylex list of elements in the specified score range.

The key of the sorted set. The min value to filter by. The max value to filter by. Which of and to exclude (defaults to both inclusive). Whether to order the data ascending or descending How many items to skip. How many items to take. The flags to use for this operation. https://redis.io/commands/zrangebylex https://redis.io/commands/zrevrangebylex 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.

The key of the sorted set. The member to get the rank of. The order to sort by (defaults to ascending). The flags to use for this operation. 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 https://redis.io/commands/zrank https://redis.io/commands/zrevrank

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

The key of the sorted set. The member to remove. The flags to use for this operation. True if the member existed in the sorted set and was removed; False otherwise. https://redis.io/commands/zrem

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

The key of the sorted set. The members to remove. The flags to use for this operation. The number of members removed from the sorted set, not including non existing members. https://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 key of the sorted set. The minimum rank to remove. The maximum rank to remove. The flags to use for this operation. The number of elements removed. https://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 key of the sorted set. The minimum score to remove. The maximum score to remove. Which of and to exclude (defaults to both inclusive). The flags to use for this operation. The number of elements removed. https://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.

The key of the sorted set. The minimum value to remove. The maximum value to remove. Which of and to exclude (defaults to both inclusive). The flags to use for this operation. the number of elements removed. https://redis.io/commands/zremrangebylex

The ZSCAN command is used to incrementally iterate over a sorted set

The key of the sorted set. The pattern to match. The page size to iterate by. The flags to use for this operation. Yields all matching elements of the sorted set. https://redis.io/commands/zscan

The ZSCAN command is used to incrementally iterate over a sorted set; note: to resume an iteration via cursor, cast the original enumerable or enumerator to IScanningCursor.

The key of the sorted set. The pattern to match. The page size to iterate by. The cursor position to start at. The page offset to start at. The flags to use for this operation. Yields all matching elements of the sorted set. https://redis.io/commands/zscan

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 key of the sorted set. The member to get a score for. The flags to use for this operation. The score of the member. https://redis.io/commands/zscore

Removes and returns the first element from the sorted set stored at key, by default with the scores ordered from low to high.

The key of the sorted set. The order to sort by (defaults to ascending). The flags to use for this operation. The removed element, or nil when key does not exist. https://redis.io/commands/zpopmin https://redis.io/commands/zpopmax

Removes and returns the specified number of first elements from the sorted set stored at key, by default with the scores ordered from low to high.

The key of the sorted set. The number of elements to return. The order to sort by (defaults to ascending). The flags to use for this operation. An array of elements, or an empty array when key does not exist. https://redis.io/commands/zpopmin https://redis.io/commands/zpopmax

Allow the consumer to mark a pending message as correctly processed. Returns the number of messages acknowledged.

The key of the stream. The name of the consumer group that received the message. The ID of the message to acknowledge. The flags to use for this operation. The number of messages acknowledged. https://redis.io/topics/streams-intro

Allow the consumer to mark a pending message as correctly processed. Returns the number of messages acknowledged.

The key of the stream. The name of the consumer group that received the message. The IDs of the messages to acknowledge. The flags to use for this operation. The number of messages acknowledged. https://redis.io/topics/streams-intro

Adds an entry using the specified values to the given stream key. If key does not exist, a new key holding a stream is created. The command returns the ID of the newly created stream entry.

The key of the stream. The field name for the stream entry. The value to set in the stream entry. The ID to assign to the stream entry, defaults to an auto-generated ID ("*"). The maximum length of the stream. If true, the "~" argument is used to allow the stream to exceed max length by a small number. This improves performance when removing messages. The flags to use for this operation. The ID of the newly created message. https://redis.io/commands/xadd

Adds an entry using the specified values to the given stream key. If key does not exist, a new key holding a stream is created. The command returns the ID of the newly created stream entry.

The key of the stream. The fields and their associated values to set in the stream entry. The ID to assign to the stream entry, defaults to an auto-generated ID ("*"). The maximum length of the stream. If true, the "~" argument is used to allow the stream to exceed max length by a small number. This improves performance when removing messages. The flags to use for this operation. The ID of the newly created message. https://redis.io/commands/xadd

Change ownership of messages consumed, but not yet acknowledged, by a different consumer. This method returns the complete message for the claimed message(s).

The key of the stream. The consumer group. The consumer claiming the given message(s). The minimum message idle time to allow the reassignment of the message(s). The IDs of the messages to claim for the given consumer. The flags to use for this operation. The messages successfully claimed by the given consumer. https://redis.io/topics/streams-intro

Change ownership of messages consumed, but not yet acknowledged, by a different consumer. This method returns the IDs for the claimed message(s).

The key of the stream. The consumer group. The consumer claiming the given message(s). The minimum message idle time to allow the reassignment of the message(s). The IDs of the messages to claim for the given consumer. The flags to use for this operation. The message IDs for the messages successfully claimed by the given consumer. https://redis.io/topics/streams-intro

Set the position from which to read a stream for a consumer group.

The key of the stream. The name of the consumer group. The position from which to read for the consumer group. The flags to use for this operation. True if successful, otherwise false.

Retrieve information about the consumers for the given consumer group. This is the equivalent of calling "XINFO GROUPS key group".

The key of the stream. The consumer group name. The flags to use for this operation. An instance of for each of the consumer group's consumers. https://redis.io/topics/streams-intro

Create a consumer group for the given stream.

The key of the stream. The name of the group to create. The position to begin reading the stream. Defaults to . The flags to use for this operation. True if the group was created. https://redis.io/topics/streams-intro

Create a consumer group for the given stream.

The key of the stream. The name of the group to create. The position to begin reading the stream. Defaults to . Create the stream if it does not already exist. The flags to use for this operation. True if the group was created. https://redis.io/topics/streams-intro

Delete messages in the stream. This method does not delete the stream.

The key of the stream. The IDs of the messages to delete. The flags to use for this operation. Returns the number of messages successfully deleted from the stream. https://redis.io/topics/streams-intro

Delete a consumer from a consumer group.

The key of the stream. The name of the consumer group. The name of the consumer. The flags to use for this operation. The number of messages that were pending for the deleted consumer.

Delete a consumer group.

The key of the stream. The name of the consumer group. The flags to use for this operation. True if deleted, otherwise false.

Retrieve information about the groups created for the given stream. This is the equivalent of calling "XINFO GROUPS key".

The key of the stream. The flags to use for this operation. An instance of for each of the stream's groups. https://redis.io/topics/streams-intro

Retrieve information about the given stream. This is the equivalent of calling "XINFO STREAM key".

The key of the stream. The flags to use for this operation. A instance with information about the stream. https://redis.io/topics/streams-intro

Return the number of entries in a stream.

The key of the stream. The flags to use for this operation. The number of entries inside the given stream. https://redis.io/commands/xlen

View information about pending messages for a stream.

The key of the stream. The name of the consumer group The flags to use for this operation. An instance of . contains the number of pending messages, the highest and lowest ID of the pending messages, and the consumers with their pending message count. The equivalent of calling XPENDING key group. https://redis.io/commands/xpending

View information about each pending message.

The key of the stream. The name of the consumer group. The maximum number of pending messages to return. The consumer name for the pending messages. Pass RedisValue.Null to include pending messages for all consumers. The minimum ID from which to read the stream of pending messages. The method will default to reading from the beginning of the stream. The maximum ID to read to within the stream of pending messages. The method will default to reading to the end of the stream. The flags to use for this operation. An instance of for each pending message. Equivalent of calling XPENDING key group start-id end-id count consumer-name. https://redis.io/commands/xpending

Read a stream using the given range of IDs.

The key of the stream. The minimum ID from which to read the stream. The method will default to reading from the beginning of the stream. The maximum ID to read to within the stream. The method will default to reading to the end of the stream. The maximum number of messages to return. The order of the messages. will execute XRANGE and wil execute XREVRANGE. The flags to use for this operation. Returns an instance of for each message returned. https://redis.io/commands/xrange

Read from a single stream.

The key of the stream. The position from which to read the stream. The maximum number of messages to return. The flags to use for this operation. Returns a value of for each message returned. Equivalent of calling XREAD COUNT num STREAMS key id. https://redis.io/commands/xread

Read from multiple streams.

Array of streams and the positions from which to begin reading for each stream. The maximum number of messages to return from each stream. The flags to use for this operation. A value of for each stream. Equivalent of calling XREAD COUNT num STREAMS key1 key2 id1 id2. https://redis.io/commands/xread

Read messages from a stream into an associated consumer group.

The key of the stream. The name of the consumer group. The consumer name. The position from which to read the stream. Defaults to when null. The maximum number of messages to return. The flags to use for this operation. Returns a value of for each message returned. https://redis.io/commands/xreadgroup

Read messages from a stream into an associated consumer group.

The key of the stream. The name of the consumer group. The consumer name. The position from which to read the stream. Defaults to when null. The maximum number of messages to return. When true, the message will not be added to the pending message list. The flags to use for this operation. Returns a value of for each message returned. https://redis.io/commands/xreadgroup

Read from multiple streams into the given consumer group. The consumer group with the given will need to have been created for each stream prior to calling this method.

Array of streams and the positions from which to begin reading for each stream. The name of the consumer group. The maximum number of messages to return from each stream. The flags to use for this operation. A value of for each stream. Equivalent of calling XREADGROUP GROUP groupName consumerName COUNT countPerStream STREAMS stream1 stream2 id1 id2 https://redis.io/commands/xreadgroup

Read from multiple streams into the given consumer group. The consumer group with the given will need to have been created for each stream prior to calling this method.

Array of streams and the positions from which to begin reading for each stream. The name of the consumer group. The maximum number of messages to return from each stream. When true, the message will not be added to the pending message list. The flags to use for this operation. A value of for each stream. Equivalent of calling XREADGROUP GROUP groupName consumerName COUNT countPerStream STREAMS stream1 stream2 id1 id2 https://redis.io/commands/xreadgroup

Trim the stream to a specified maximum length.

The key of the stream. The maximum length of the stream. If true, the "~" argument is used to allow the stream to exceed max length by a small number. This improves performance when removing messages. The flags to use for this operation. The number of messages removed from the stream. https://redis.io/topics/streams-intro

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 key of the string. The value to append to the string. The flags to use for this operation. The length of the string after the append operation. https://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 key of the string. The start byte to count at. The end byte to count at. The flags to use for this operation. The number of bits set to 1. https://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 operation to perform. The destination key to store the result in. The first key to get the bit value from. The second key to get the bit value from. The flags to use for this operation. The size of the string stored in the destination key, that is equal to the size of the longest input string. https://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 operation to perform. The destination key to store the result in. The keys to get the bit values from. The flags to use for this operation. The size of the string stored in the destination key, that is equal to the size of the longest input string. https://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 bit 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 key of the string. True to check for the first 1 bit, false to check for the first 0 bit. The position to start looking (defaults to 0). The position to stop looking (defaults to -1, unlimited). The flags to use for this operation. 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. https://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 key of the string. The amount to decrement by (defaults to 1). The flags to use for this operation. The value of key after the decrement. https://redis.io/commands/decrby https://redis.io/commands/decr

Decrements the string representing a floating point number stored at key by the specified decrement. 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 key of the string. The amount to decrement by (defaults to 1). The flags to use for this operation. The value of key after the decrement. https://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 key of the string. The flags to use for this operation. The value of key, or nil when key does not exist. https://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.

The keys of the strings. The flags to use for this operation. The values of the strings with nil for keys do not exist. https://redis.io/commands/mget

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 key of the string. The flags to use for this operation. The value of key, or nil when key does not exist. https://redis.io/commands/get

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 key of the string. The offset in the string to get a bit at. The flags to use for this operation. The bit value stored at offset. https://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 key of the string. The start index of the substring to get. The end index of the substring to get. The flags to use for this operation. The substring of the string value stored at key. https://redis.io/commands/getrange

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

The key of the string. The value to replace the existing value with. The flags to use for this operation. The old value stored at key, or nil when key did not exist. https://redis.io/commands/getset

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 key of the string. The flags to use for this operation. The value of key and its expiry, or nil when key does not exist. https://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 key of the string. The amount to increment by (defaults to 1). The flags to use for this operation. The value of key after the increment. https://redis.io/commands/incrby https://redis.io/commands/incr

Increments 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 key of the string. The amount to increment by (defaults to 1). The flags to use for this operation. The value of key after the increment. https://redis.io/commands/incrbyfloat

Returns the length of the string value stored at key.

The key of the string. The flags to use for this operation. the length of the string at key, or 0 when key does not exist. https://redis.io/commands/strlen

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

The key of the string. The value to set. The expiry to set. Which condition to set the value under (detaults to always). The flags to use for this operation. True if the string was set, false otherwise. https://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.

The keys and values to set. Which condition to set the value under (detaults to always). The flags to use for this operation. True if the keys were set, else False https://redis.io/commands/mset https://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 key of the string. The offset in the string to set . The bit value to set, true for 1, false for 0. The flags to use for this operation. The original bit value stored at offset. https://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 key of the string. The offset in the string to overwrite. The value to overwrite with. The flags to use for this operation. The length of the string after it was modified by the command. https://redis.io/commands/setrange

Alters the last access time of a key.

The key to touch. The flags to use for this operation. True if the key was touched. https://redis.io/commands/touch

Alters the last access time of a keys. A key is ignored if it does not exist.

The keys to touch. The flags to use for this operation. The number of keys that were touched. https://redis.io/commands/touch

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

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

The key to check for. The flags to use for this operation.