The cl-redis Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The cl-redis Reference Manual

This is the cl-redis Reference Manual, version 2.3.8, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 11:21:17 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

CL-REDIS — A fast and robust Common Lisp client for Redis

(tested with Redis version 3.0.0 (2.9.104 to be precise))

Usage

Quickstart

  1. Make sure a Redis server is running.

  2. (ql:quickload 'cl-redis)

  3. Connect to the server to the given host and port with (redis:connect :host <host> :port <port>) (host defaults to 127.0.0.1, port — to 6379).

  4. Interact with the server using Redis commands from the red package.

     CL-USER> (red:ping)
     "PONG"
    
  5. Disconnect from the server with (redis:disconnect).

  6. Alternatively, wrap the whole interaction session in with-connection macro, which accepts the same arguments as connect does, opens a socket connection, executes the body of the macro with the current connection (*connection*) bound to this new connection, and ensures that the connection is closed afterwards.

Available commands

Code organization

The system provides 2 packages: REDIS and RED. All the functionality is available from the REDIS package. Not to cause symbol clashes, Redis commands are defined in this package with a prefix (which defaults to red- and is set at compilation time). The package RED is a syntactic sugar — it just provides the Redis commands without a prefix. So it is not intended to be imported to avoid symbol conflicts with package COMMON-LISP — just use the package-qualified symbol names: i.e. the same Redis command (for instance GET) can be called as RED-GET (if you import the REDIS package) or RED:GET.

Installation

Available through quicklisp.

Dependencies

Debugging and error recovery

If *echo-p* is T, all client-server communications will be echoed to the stream *echo-stream*, which defaults to *standard-output*.

Error handling is mimicked after Postmodern. In particular, whenever an error occurs that breaks the communication stream, a condition of type redis-connection-error is signalled offering a :reconnect restart. If it is selected the whole Redis command will be resent, if the reconnection attempt succeeds. Furthermore, connect checks if a connection to Redis is already established, and offers two restarts (:leave and :replace) if this is the case.

When the server respondes with an error reply (i.e., a reply that starts with -), a condition of type redis-error-reply is signalled.

There's also a high-level with-persistent-connection macro, that tries to do the right thing™ (i.e. automatically reopen the connection once, if it is broken).

Advanced usage

PubSub

Since there's no special command to receive messages from Redis via PubSub here's how you do it:

(bt:make-thread (lambda ()
                  (with-connection ()
                    (red:subscribe "foo")
                    (loop :for msg := (expect :anything) :do
                      (print msg))))
                "pubsub-listener")

To publish, obviously:

(with-connection ()
  (red:publish "foo" "test"))

Pipelining

For better performance Redis allows to pipeline commands and delay receiving results until the end, and process them all in oine batch afterwards. To support that there's with-pipelining macro. Compare execution times in the following examples (with pipelining and without: 6.567 secs vs. 2023.924 secs!):

(let ((names (let (acc)
               (dotimes (i 1000 (nreverse acc))
                 (push (format nil "n~a" i) acc))))
      (vals  (let (big-acc)
               (dotimes (i 1000 (nreverse big-acc))
                 (let (acc)
                   (dotimes (i (random 100))
                     (push (list (random 10) (format nil "n~a" i)) acc))
                   (push (nreverse acc) big-acc))))))
  (time (redis:with-connection ()
          (redis:with-pipelining
            (loop :for k :in names :for val :in vals :do
              (dolist (v val)
                (apply #'red:zadd k v)))
            (red:zunionstore "result" (length names) names)
            (red:zrange "result" 0 -1))))

  ;; Evaluation took:
  ;;  6.567 seconds of real time
  ;;  3.900243 seconds of total run time (3.200200 user, 0.700043 system)

  (time (redis:with-connection ()
          (loop :for k :in names :for val :in vals :do
            (dolist (v val)
              (apply #'red:zadd k v)))
          (red:zunionstore "result" (length names) names)
          (red:zrange "result" 0 -1))))

  ;; Evaluation took:
  ;; 2023.924 seconds of real time
  ;; 3.560222 seconds of total run time (2.976186 user, 0.584036 system)

Note, that with-pipelining calls theoretically may nest, but the results will only be available to the highest-level pipeline, all the nested pipelines will return :PIPELINED. So a warining is signalled in this situation.

Internals

Generic functions tell and expect implement the Redis protocol according to the spec. tell specifies how a request to Redis is formatted, expect — how the response is handled. The best way to implement another method on expect is usually with def-expect-method, which arranges reading data from the socket and provides a variable reply, which holds the decoded reply data from the server with the initial character removed. For example:

(def-expect-method :ok
  (assert (string= reply "OK"))
  reply)

Redis operations are defined as ordinary functions by def-cmd for which only arguments and return type should be provided. def-cmd prefixes all the defined functions' names with *cmd-prefix*, which defaults to 'red. (Note, that setting of *cmd-prefix* will have its effects at compile time). It also exports them from REDIS package, and from RED package without the prefix.

An example of command definition is given below:

(def-cmd KEYS (pattern) :multi
  "Return all the keys matching the given pattern.")

See commands.lisp for all defined commands.

Not implemented

Credits

The library is developed and maintained by Vsevolod Dyomkin vseloved@gmail.com.

At the initial stages Alexandr Manzyuk manzyuk@googlemail.com developed the connection handling code following the implementation in Postmodern. It was since partially rewritten to accommodate more advanced connection handling strategies, like persistent connection.

License

MIT (See LICENSE file


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 cl-redis

Maintainer

Vsevolod Dyomkin <vseloved@gmail.com>

Author

Vsevolod Dyomkin <vseloved@gmail.com>

License

MIT

Description

A fast and robust Common Lisp client for Redis

Version

2.3.8

Dependencies
Source

cl-redis.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 cl-redis.asd

Location

cl-redis.asd

Systems

cl-redis (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.2 cl-redis/package.lisp

Parent

cl-redis (system)

Location

package.lisp

Packages

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.3 cl-redis/float.lisp

Dependency

package.lisp (file)

Parent

cl-redis (system)

Location

float.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.4 cl-redis/connection.lisp

Dependency

float.lisp (file)

Parent

cl-redis (system)

Location

connection.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.5 cl-redis/redis.lisp

Dependency

connection.lisp (file)

Parent

cl-redis (system)

Location

redis.lisp

Exported Definitions
Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

3.1.6 cl-redis/commands.lisp

Dependency

redis.lisp (file)

Parent

cl-redis (system)

Location

commands.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

4.1 red

Source

package.lisp (file)


Previous: , Up: Packages   [Contents][Index]

4.2 redis

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Special variables

Special Variable: *cmd-prefix*

Prefix for functions names that implement Redis commands.

Package

redis

Source

redis.lisp (file)

Special Variable: *connection*

The current Redis connection.

Package

redis

Source

connection.lisp (file)

Special Variable: *echo-p*

Whether the server-client communication should be echoed to the stream specified by *ECHO-STREAM*. The default is NIL, meaning no echoing.

Package

redis

Source

connection.lisp (file)

Special Variable: *echo-stream*

A stream to which the server-client communication will be echoed for debugging purposes. The default is *STANDARD-OUTPUT*.

Package

redis

Source

connection.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Macros

Macro: def-cmd CMD (&rest ARGS) REPLY-TYPE DOCSTRING

Define and export a function with the name <*CMD-REDIX*>-<CMD> for processing a Redis command CMD. Here REPLY-TYPE is the expected reply format.

Package

redis

Source

redis.lisp (file)

Macro: def-expect-method TYPE &body BODY

Define a specialized EXPECT method. BODY may refer to the ~ variable REPLY, which is bound to the reply received from Redis ~ server with the first character removed.

Package

redis

Source

redis.lisp (file)

Macro: with-connection (&key HOST PORT AUTH) &body BODY

Evaluate BODY with the current connection bound to a new connection specified by the given HOST and PORT

Package

redis

Source

connection.lisp (file)

Macro: with-persistent-connection (&key HOST PORT AUTH) &body BODY

Execute BODY inside WITH-CONNECTION. But if connection is broken due to REDIS-CONNECTION-ERROR (a network error or timeout), transparently reopen it.

Package

redis

Source

connection.lisp (file)

Macro: with-pipelining &body BODY

Delay execution of EXPECT’s inside BODY to the end, so that all commands are first sent to the server and then their output is received and collected into a list. So commands return :PIPELINED instead of the expected results.

Package

redis

Source

redis.lisp (file)

Macro: with-recursive-connection (&key HOST PORT AUTH) &body BODY

Execute BODY with *CONNECTION* bound to the default Redis connection. If connection is already established, reuse it.

Package

redis

Source

connection.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 Functions

Function: close-connection CONN

Close the socket of CONN.

Package

redis

Source

connection.lisp (file)

Function: connect &key HOST PORT AUTH

Connect to Redis server.

Package

redis

Source

connection.lisp (file)

Function: connected-p ()

Is there a current connection?

Package

redis

Source

connection.lisp (file)

Function: disconnect ()

Disconnect from Redis server.

Package

redis

Source

connection.lisp (file)

Function: open-connection CONN

Create a socket connection to the host and port of CONNECTION and set the socket of CONN to the associated socket.

Package

redis

Source

connection.lisp (file)

Function: reconnect ()

Close and reopen the connection to Redis server.

Package

redis

Source

connection.lisp (file)

Function: red-append KEY VALUE

Append the specified string to the string stored at key.

Package

redis

Source

commands.lisp (file)

Function: red-auth PASS

Simple password authentication if enabled.

Package

redis

Source

commands.lisp (file)

Function: red-bgrewriteaof ()

Rewrite the append only file in background when it gets too big.

Package

redis

Source

commands.lisp (file)

Function: red-bgsave ()

Asynchronously save the DB on disk.

Package

redis

Source

commands.lisp (file)

Function: red-bitcount KEY &optional START END

Count set bits in a string at KEY
(with optional bounding indices START and END).

Package

redis

Source

commands.lisp (file)

Function: red-bitop OPERATION DESTKEY KEY &rest KEYS

Perform bitwise OPERATION between strings ar KEY and KEYS and store the result ad DSTKEY.

Package

redis

Source

commands.lisp (file)

Function: red-bitpos KEY BIT &optional START END

Return the position of the first bit set to 1 or 0 in a string.

Package

redis

Source

commands.lisp (file)

Function: red-blpop &rest KEYS-AND-TIMEOUT

Blocking LPOP.

Package

redis

Source

commands.lisp (file)

Function: red-brpop &rest KEYS-AND-TIMEOUT

Blocking RPOP.

Package

redis

Source

commands.lisp (file)

Function: red-brpoplpush SOURCE DESTINATION TIMEOUT

BRPOPLPUSH is the blocking variant of RPOPLPUSH. When source contains elements, this command behaves exactly like RPOPLPUSH. When source is empty, Redis will block the connection until another client pushes to it or until TIMEOUT is reached. A TIMEOUT of zero can be used to block indefinitely. See RPOPLPUSH for more information.

Package

redis

Source

commands.lisp (file)

Function: red-client-getname ()

The CLIENT GETNAME returns the name of the current connection as set by CLIENT SETNAME. Since every new connection starts without an associated name, if no name was assigned a null bulk reply is returned.

Package

redis

Source

commands.lisp (file)

Function: red-client-pause TIMEOUT

CLIENT PAUSE is a connections control command able to suspend all the Redis clients for the specified amount of time (in milliseconds).

Package

redis

Source

commands.lisp (file)

Function: red-client-setname CONNECTION-NAME

The CLIENT SETNAME command assigns a name to the current connection. The assigned name is displayed in the output of CLIENT LIST so that it is possible to identify the client that performed a given connection.

Package

redis

Source

commands.lisp (file)

Function: red-cluster-slots ()

CLUSTER SLOTS returns details about which cluster slots map to which Redis instances.

Package

redis

Source

commands.lisp (file)

Function: red-command ()

Returns Array reply of details about all Redis commands.
Cluster clients must be aware of key positions in commands so commands can go to matching instances, but Redis commands vary between accepting one key, multiple keys, or even multiple keys separated by other data.
You can use COMMAND to cache a mapping between commands and key positions for each command to enable exact routing of commands to cluster instances.

Package

redis

Source

commands.lisp (file)

Function: red-command-count ()

Returns Integer reply of number of total commands in this Redis server.

Package

redis

Source

commands.lisp (file)

Function: red-command-getkeys COMMAND-NAME &rest ARGS

Returns Array reply of keys from a full Redis command.
COMMAND GETKEYS is a helper command to let you find the keys from
a full Redis command.
COMMAND shows some commands as having movablekeys meaning the entire command must be parsed to discover storage or retrieval keys.
You can use COMMAND GETKEYS to discover key positions directly from how Redis parses the commands.

Package

redis

Source

commands.lisp (file)

Function: red-command-info COMMAND-NAME &rest ARGS

Returns Array reply of details about multiple Redis commands.
Same result format as COMMAND except you can specify which commands get returned.
If you request details about non-existing commands, their return position will be nil.

Package

redis

Source

commands.lisp (file)

Function: red-config-get PATTERN

Configure a Redis server at runtime: get glob PATTERN value.

Package

redis

Source

commands.lisp (file)

Function: red-config-resetstat ()

Resets the statistics reported by Redis using the INFO command.

Package

redis

Source

commands.lisp (file)

Function: red-config-rewrite ()

The CONFIG REWRITE command rewrites the redis.conf file the server
was started with, applying the minimal changes needed to make it reflecting the configuration currently used by the server, that may be different compared to the original one because of the use of the CONFIG SET command.

Package

redis

Source

commands.lisp (file)

Function: red-config-set PARAMETER VALUE

Configure a Redis server at runtime: set PARAMETER VALUE.

Package

redis

Source

commands.lisp (file)

Function: red-dbsize ()

Return the number of keys in the current db.

Package

redis

Source

commands.lisp (file)

Function: red-decr KEY

Decrement the integer value of KEY.

Package

redis

Source

commands.lisp (file)

Function: red-decrby KEY DECREMENT

Decrement the integer value of KEY by DECREMENT.

Package

redis

Source

commands.lisp (file)

Function: red-del KEY &rest KEYS

Delete a key.

Package

redis

Source

commands.lisp (file)

Function: red-discard ()

Redis atomic transactions’ rollback.

Package

redis

Source

commands.lisp (file)

Function: red-dump KEY

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

Package

redis

Source

commands.lisp (file)

Function: red-echo MESSAGE

Returns message.

Package

redis

Source

commands.lisp (file)

Function: red-eval SCRIPT NUMKEYS &rest KEY-VALUES

Execute a Lua script server side.

Package

redis

Source

commands.lisp (file)

Function: red-evalsha SHA1 NUMKEYS &rest KEY-VALUES

Execute a stored Lua script server side.

Package

redis

Source

commands.lisp (file)

Function: red-exec ()

Redis atomic transactions’ commit.

Package

redis

Source

commands.lisp (file)

Function: red-exists KEY

Test if a key exists.

Package

redis

Source

commands.lisp (file)

Function: red-expire KEY SECS

Set a time to live in SECS on KEY.

Package

redis

Source

commands.lisp (file)

Function: red-expireat KEY TIMESTAMP

Set a timeout on KEY. After the timeout has expired, the key will automatically be deleted.
EXPIREAT has the same effect and semantic as EXPIRE, but instead of specifying the number of seconds representing the TTL, it takes
an absolute UNIX timestamp (seconds since January 1, 1970).
As in the case of EXPIRE command, if key is updated before the timeout has expired, then the timeout is removed as if the PERSIST command was invoked on KEY.

Package

redis

Source

commands.lisp (file)

Function: red-flushall ()

Remove all the keys from all the databases.

Package

redis

Source

commands.lisp (file)

Function: red-flushdb ()

Remove all the keys of the currently selected DB.

Package

redis

Source

commands.lisp (file)

Function: red-get KEY

Return the string value of the key.

Package

redis

Source

commands.lisp (file)

Function: red-getbit KEY OFFSET

Returns the bit value at OFFSET in the string value stored at KEY.

Package

redis

Source

commands.lisp (file)

Function: red-getrange KEY OFFSET VALUE

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.

Package

redis

Source

commands.lisp (file)

Function: red-getset KEY VALUE

Set a key to a string returning the old value of the key.

Package

redis

Source

commands.lisp (file)

Function: red-hdel KEY FIELD

Remove the specified FIELD from a hash.

Package

redis

Source

commands.lisp (file)

Function: red-hexists KEY FIELD

Test for existence of a specified FIELD in a hash.

Package

redis

Source

commands.lisp (file)

Function: red-hget KEY FIELD

Retrieve the value of the specified hash FIELD.

Package

redis

Source

commands.lisp (file)

Function: red-hgetall KEY

Return all the fields and associated values in a hash.

Package

redis

Source

commands.lisp (file)

Function: red-hincrby KEY FIELD INTEGER

Increment the integer value of the hash at KEY on FIELD with INTEGER.

Package

redis

Source

commands.lisp (file)

Function: red-hincrbyfloat KEY FIELD INCREMENT

Increment the float value of the hash at KEY on FIELD with INCREMENT.

Package

redis

Source

commands.lisp (file)

Function: red-hkeys KEY

Return all the fields in a hash.

Package

redis

Source

commands.lisp (file)

Function: red-hlen KEY

Return the number of items in a hash.

Package

redis

Source

commands.lisp (file)

Function: red-hmget KEY FIELD &rest FIELDS

Get the values associated with the specified FIELDS in the hash stored at KEY.

Package

redis

Source

commands.lisp (file)

Function: red-hmset KEY &rest FIELDS-AND-VALUES

Set the hash FIELDS to their respective VALUES.

Package

redis

Source

commands.lisp (file)

Function: red-hscan KEY CURSOR &rest ARGS &key MATCH COUNT

The HSCAN command and the closely related commands SCAN, SSCAN and ZSCAN are used in order to incrementally iterate over a collection of elements. HSCAN iterates fields of Hash types and their associated values.

Package

redis

Source

commands.lisp (file)

Function: red-hset KEY FIELD VALUE

Set the hash FIELD to the specified VALUE. Creates the hash if needed.

Package

redis

Source

commands.lisp (file)

Function: red-hsetnx KEY FIELD VALUE

Set the hash FIELD to the specified VALUE, if the KEY doesn’t exist yet.

Package

redis

Source

commands.lisp (file)

Function: red-hvals KEY

Return all the values in a hash.

Package

redis

Source

commands.lisp (file)

Function: red-incr KEY

Increment the integer value of KEY.

Package

redis

Source

commands.lisp (file)

Function: red-incrby KEY INCREMENT

Increment the integer value of KEY by .

Package

redis

Source

commands.lisp (file)

Function: red-incrbyfloat KEY INCREMENT

Increment the float value of KEY by INCREMENT.

Package

redis

Source

commands.lisp (file)

Function: red-info &optional SECTION

Provide information and statistics about the server.

Package

redis

Source

commands.lisp (file)

Function: red-keys PATTERN

Return all the keys matching a given pattern.

Package

redis

Source

commands.lisp (file)

Function: red-lastsave ()

Return the UNIX time stamp of the last successfully saving of the dataset on disk.

Package

redis

Source

commands.lisp (file)

Function: red-lindex KEY INDEX

Return the element at index position from the List at key.

Package

redis

Source

commands.lisp (file)

Function: red-linsert KEY BEFORE/AFTER PIVOT VALUE

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. An error is returned when KEY exists, but does not hold a list value PIVOT.

Note: before/after can only have 2 values: :before or :after.

Package

redis

Source

commands.lisp (file)

Function: red-llen KEY

Return the length of the List value at key.

Package

redis

Source

commands.lisp (file)

Function: red-lpop KEY

Return and remove (atomically) the first element of the List at key.

Package

redis

Source

commands.lisp (file)

Function: red-lpush KEY VALUE

Append an element to the head of the list value at KEY.

Package

redis

Source

commands.lisp (file)

Function: red-lpushx KEY VALUE

Inserts value at the head of the list stored at KEY, only if KEY already exists and holds a list. In contrary to LPUSH, no operation will be performed when KEY does not yet exist.

Package

redis

Source

commands.lisp (file)

Function: red-lrange KEY START END

Return a range of elements from the List at key.

Package

redis

Source

commands.lisp (file)

Function: red-lrem KEY COUNT VALUE

Remove the first-N, last-N, or all the elements matching value from the List at key.

Package

redis

Source

commands.lisp (file)

Function: red-lset KEY INDEX VALUE

Set a new value as the element at index position of the List at key.

Package

redis

Source

commands.lisp (file)

Function: red-ltrim KEY START END

Trim the list at key to the specified range of elements.

Package

redis

Source

commands.lisp (file)

Function: red-mget &rest KEYS

Multi-get, return the strings values of the keys.

Package

redis

Source

commands.lisp (file)

Function: red-migrate HOST PORT KEY DESTINATION-DB TIMEOUT

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

Package

redis

Source

commands.lisp (file)

Function: red-move KEY DBINDEX

Move the key from the currently selected DB to the DB having as index dbindex.

Package

redis

Source

commands.lisp (file)

Function: red-mset &rest KEY-VALUE-PLIST

Set multiple keys to multiple values in a single atomic operation.

Package

redis

Source

commands.lisp (file)

Function: red-msetnx &rest KEY-VALUE-PLIST

Set multiple keys to multiple values in a single atomic operation if none of the keys already exist.

Package

redis

Source

commands.lisp (file)

Function: red-multi ()

Redis atomic transactions’ start.

Package

redis

Source

commands.lisp (file)

Function: red-object-encoding KEY

The OBJECT command allows to inspect the internals of Redis Objects
associated with keys. It is useful for debugging or to understand if your keys are using the specially encoded data types to save space. Your application may also use the information reported by the OBJECT command to implement application level key eviction policies when using Redis as a Cache.
OBJECT ENCODING <key> returns the kind of internal representation used in order to store the value associated with a key.

Package

redis

Source

commands.lisp (file)

Function: red-object-idletime KEY

The OBJECT command allows to inspect the internals of Redis Objects
associated with keys. It is useful for debugging or to understand if your keys are using the specially encoded data types to save space. Your application may also use the information reported by the OBJECT command to implement application level key eviction policies when using Redis as a Cache.
OBJECT IDLETIME <key> returns the number of seconds since the object stored at the specified key is idle (not requested by read or write operations). While the value is returned in seconds the actual resolution of this timer is 10 seconds, but may vary in future implementations.

Package

redis

Source

commands.lisp (file)

Function: red-object-refcount KEY

The OBJECT command allows to inspect the internals of Redis Objects
associated with keys. It is useful for debugging or to understand if your keys are using the specially encoded data types to save space. Your application may also use the information reported by the OBJECT command to implement application level key eviction policies when using Redis as a Cache.
OBJECT REFCOUNT <key> returns the number of references of the value associated with the specified key.

Package

redis

Source

commands.lisp (file)

Function: red-persist KEY

Remove the existing timeout on KEY.

Package

redis

Source

commands.lisp (file)

Function: red-pexpire KEY MILLISECONDS

Set a KEY’s time to live in MILLISECONDS.

Package

redis

Source

commands.lisp (file)

Function: red-pexpireat KEY MILLISECONDS-TIMESTAMP

Set the expiration for a KEY as a Unix timestamp specified in milliseconds.

Package

redis

Source

commands.lisp (file)

Function: red-pfadd KEY ELEMENT &rest ELEMENTS

Adds all the element arguments to the HyperLogLog data structure stored
at the variable name specified as first argument.
As a side effect of this command the HyperLogLog internals may be updated to reflect a different estimation of the number of unique items added so far (the cardinality of the set).
If the approximated cardinality estimated by the HyperLogLog changed after executing the command, PFADD returns 1, otherwise 0 is returned.
The command automatically creates an empty HyperLogLog structure (that is, a Redis String of a specified length and with a given encoding) if
the specified key does not exist.
To call the command without elements but just the variable name is valid, this will result into no operation performed if the variable already exists, or just the creation of the data structure if the key does not exist
(in the latter case 1 is returned).

Package

redis

Source

commands.lisp (file)

Function: red-pfcount KEY &rest KEYS

When called with a single key, returns the approximated cardinality computed by the HyperLogLog data structure stored at the specified variable,
which is 0 if the variable does not exist.
When called with multiple keys, 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.
The HyperLogLog data structure can be used in order to count unique elements in a set using just a small constant amount of memory, specifically 12k bytes for every HyperLogLog (plus a few bytes for the key itself).
The returned cardinality of the observed set is not exact, but approximated with a standard error of 0.81%.
For example, in order to take the count of all the unique search queries performed in a day, a program needs to call PFADD every time a query is processed. The estimated number of unique queries can be retrieved with PFCOUNT at any time.
Note: as a side effect of calling this function, it is possible that
the HyperLogLog is modified, since the last 8 bytes encode the latest computed cardinality for caching purposes. So PFCOUNT is technically
a write command.

Package

redis

Source

commands.lisp (file)

Function: red-pfmerge DESTKEY SOURCEKEY &rest SOURCEKEYS

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 computed merged HyperLogLog is set to the destination variable, which is created if does not exist (defaulting to an empty HyperLogLog).

Package

redis

Source

commands.lisp (file)

Function: red-ping ()

Ping server.

Package

redis

Source

commands.lisp (file)

Function: red-psubscribe &rest PATTERNS

Redis Public/Subscribe messaging paradigm implementation.

Package

redis

Source

commands.lisp (file)

Function: red-pttl KEY

Get the time to live in milliseconds of KEY.

Package

redis

Source

commands.lisp (file)

Function: red-publish CHANNEL MESSAGE

Redis Public/Subscribe messaging paradigm implementation.

Package

redis

Source

commands.lisp (file)

Function: red-punsubscribe &rest PATTERNS

Redis Public/Subscribe messaging paradigm implementation.

Package

redis

Source

commands.lisp (file)

Function: red-quit ()

Close the connection.

Package

redis

Source

commands.lisp (file)

Function: red-randomkey ()

Return a random key from the key space.

Package

redis

Source

commands.lisp (file)

Function: red-rename OLDNAME NEWNAME

Rename the old key in the new one, destroing the newname key if it already exists.

Package

redis

Source

commands.lisp (file)

Function: red-renamenx OLDNAME NEWNAME

Rename the old key in the new one, if the newname key does not already exist.

Package

redis

Source

commands.lisp (file)

Function: red-restore KEY TTL SERIALIZED-VALUE

Create a KEY using the provided SERIALIZED-VALUE, previously obtained using DUMP.

Package

redis

Source

commands.lisp (file)

Function: red-role ()

Provide information on the role of a Redis instance in the context
of replication, by returning if the instance is currently a master, slave, or sentinel. The command also returns additional information about the state of the replication (if the role is master or slave) or the list of monitored master names (if the role is sentinel).

Package

redis

Source

commands.lisp (file)

Function: red-rpop KEY

Return and remove (atomically) the last element of the List at key.

Package

redis

Source

commands.lisp (file)

Function: red-rpoplpush SOURCE DESTINATION

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.
For example: consider SOURCE holding the list a,b,c, and DESTINATION holding the list x,y,z. Executing RPOPLPUSH results in SOURCE holding a,b and DESTINATION holding c,x,y,z.
If SOURCE does not exist, the value nil is returned and no operation is performed. If SOURCE and DESTINATION are the same, the operation is equivalent to removing the last element from the list and pushing it as first element of the list, so it can be considered as a list rotation command.

Package

redis

Source

commands.lisp (file)

Function: red-rpush KEY VALUE

Append an element to the tail of the list value at KEY.

Package

redis

Source

commands.lisp (file)

Function: red-rpushx KEY VALUE

Inserts value at the tail of the list stored at KEY, only if KEY already exists and holds a list. In contrary to RPUSH, no operation will be performed when KEY does not yet exist.

Package

redis

Source

commands.lisp (file)

Function: red-sadd KEY &rest MEMBERS

Add the specified member to the Set value at key.

Package

redis

Source

commands.lisp (file)

Function: red-save ()

Synchronously save the DB on disk.

Package

redis

Source

commands.lisp (file)

Function: red-scan CURSOR &rest ARGS &key MATCH COUNT

The SCAN command and the closely related commands SSCAN, HSCAN and ZSCAN are used in order to incrementally iterate over a collection of elements. SCAN iterates the set of keys in the currently selected Redis database.

Package

redis

Source

commands.lisp (file)

Function: red-scard KEY

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

Package

redis

Source

commands.lisp (file)

Function: red-script-exists SCRIPT &rest SCRIPTS

Check existence of scripts in the script cache.

Package

redis

Source

commands.lisp (file)

Function: red-script-flush ()

Remove all the scripts from the script cache.

Package

redis

Source

commands.lisp (file)

Function: red-script-kill ()

Kill the script currently in execution.

Package

redis

Source

commands.lisp (file)

Function: red-script-load SCRIPT

Load the specified Lua script into the script cache.

Package

redis

Source

commands.lisp (file)

Function: red-sdiff &rest KEYS

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

Package

redis

Source

commands.lisp (file)

Function: red-sdiffstore DSTKEY &rest KEYS

Compute the difference between the Set key1 and all the Sets key2, ..., keyN, and store the resulting Set at dstkey.

Package

redis

Source

commands.lisp (file)

Function: red-select INDEX

Select the DB having the specified index.

Package

redis

Source

commands.lisp (file)

Function: red-set KEY VALUE

Set a key to a string value.

Package

redis

Source

commands.lisp (file)

Function: red-setbit KEY OFFSET VALUE

Sets or clears the bit at OFFSET in the string value stored at KEY.

Package

redis

Source

commands.lisp (file)

Function: red-setex KEY TIME VALUE

Set KEY to hold the string VALUE and set KEY to timeout after a given number of seconds. This command is equivalent to executing the following commands: SET mykey value
EXPIRE mykey seconds
SETEX is atomic, and can be reproduced by using the previous two commands inside an MULTI/EXEC block. It is provided as a faster alternative to the given sequence of operations, because this operation is very common when Redis is used as a cache.
An error is returned when seconds is invalid.

Package

redis

Source

commands.lisp (file)

Function: red-setnx KEY VALUE

Set a key to a string value if the key does not exist.

Package

redis

Source

commands.lisp (file)

Function: red-setrange KEY OFFSET VALUE

Overwrites part of the string stored at KEY, starting at the specified OFFSET, for the entire length of VALUE. If the OFFSET is larger than the current length of the string at KEY, the string is padded with zero-bytes to make OFFSET fit. Non-existing keys are considered as empty strings, so this command will make sure it holds a string large enough to be able to set value at OFFSET. Note that the maximum OFFSET that you can set is 229^-1 (536870911), as Redis Strings are limited to 512 megabytes.

Package

redis

Source

commands.lisp (file)

Function: red-shutdown ()

Synchronously save the DB on disk, then shutdown the server.

Package

redis

Source

commands.lisp (file)

Function: red-sinter &rest KEYS

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

Package

redis

Source

commands.lisp (file)

Function: red-sinterstore DSTKEY &rest KEYS

Compute the intersection between the Sets stored at key1, key2, ..., keyN, and store the resulting Set at dstkey.

Package

redis

Source

commands.lisp (file)

Function: red-sismember KEY MEMBER

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

Package

redis

Source

commands.lisp (file)

Function: red-slaveof HOSTNAME PORT

Change the replication settings.

Package

redis

Source

commands.lisp (file)

Function: red-slowlog SUBCOMMAND &optional ARGUMENT

Manages the Redis slow queries log.

Package

redis

Source

commands.lisp (file)

Function: red-smembers KEY

Return all the members of the Set value at key.

Package

redis

Source

commands.lisp (file)

Function: red-smove SRCKEY DSTKEY MEMBER

Move the specified member from one Set to another atomically.

Package

redis

Source

commands.lisp (file)

Function: red-sort KEY &rest ARGS &key BY START END GET DESC ALPHA STORE

Sort a Set or a List accordingly to the specified parameters.

Package

redis

Source

commands.lisp (file)

Function: red-spop KEY

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

Package

redis

Source

commands.lisp (file)

Function: red-srandmember KEY &optional COUNT

Get one or COUNT random members from a set at KEY.
When called with the additional count argument,
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.

Package

redis

Source

commands.lisp (file)

Function: red-srem KEY &rest MEMBERS

Remove the specified member from the Set value at key.

Package

redis

Source

commands.lisp (file)

Function: red-sscan KEY CURSOR &rest ARGS &key MATCH COUNT

The SCAN command and the closely related commands SCAN, HSCAN and ZSCAN are used in order to incrementally iterate over a collection of elements. SSCAN iterates elements of Sets types.

Package

redis

Source

commands.lisp (file)

Function: red-strlen KEY

Returns the length of the string value stored at KEY.

Package

redis

Source

commands.lisp (file)

Function: red-subscribe &rest CHANNELS

Redis Public/Subscribe messaging paradigm implementation.

Package

redis

Source

commands.lisp (file)

Function: red-substr KEY START END

Return a substring out of a larger string.
Warning: left for backwards compatibility. It is now called: GETRANGE.

Package

redis

Source

commands.lisp (file)

Function: red-sunion &rest KEYS

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

Package

redis

Source

commands.lisp (file)

Function: red-sunionstore DSTKEY &rest KEYS

Compute the union between the Sets stored at key1, key2, ..., keyN, and store the resulting Set at dstkey.

Package

redis

Source

commands.lisp (file)

Function: red-sync ()

Synchronize with slave.

Package

redis

Source

commands.lisp (file)

Function: red-time ()

The TIME command returns the current server time as a two items lists: a Unix timestamp and the amount of microseconds already elapsed in the current second.
Basically the interface is very similar to the one of the gettimeofday system call.

Package

redis

Source

commands.lisp (file)

Function: red-ttl KEY

Get the time to live in seconds of KEY.

Package

redis

Source

commands.lisp (file)

Function: red-type KEY

Return the type of the value stored at key.

Package

redis

Source

commands.lisp (file)

Function: red-unsubscribe &rest CHANNELS

Redis Public/Subscribe messaging paradigm implementation.

Package

redis

Source

commands.lisp (file)

Function: red-unwatch ()

Flushes all the previously watched keys for a transaction.
If you call EXEC or DISCARD, there’s no need to manually call UNWATCH.

Package

redis

Source

commands.lisp (file)

Function: red-watch KEY &rest KEYS

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

Package

redis

Source

commands.lisp (file)

Function: red-zadd KEY &rest SCORE-MEMBER-PAIRS

Add the specified MEMBER to the Set value at KEY or update the SCORE if it already exist. If nil is returned, the element already existed in the set. Just the score was updated.

Package

redis

Source

commands.lisp (file)

Function: red-zcard KEY

Return the cardinality (number of elements) of the sorted set at KEY.

Package

redis

Source

commands.lisp (file)

Function: red-zcount KEY MIN MAX

Returns the number of elements in the sorted set at KEY with a score between MIN and MAX.

Package

redis

Source

commands.lisp (file)

Function: red-zincrby KEY INCREMENT MEMBER

If the MEMBER already exists increment its score by INCREMENT, otherwise add the member setting INCREMENT as score.

Package

redis

Source

commands.lisp (file)

Function: red-zinterstore DSTKEY N KEYS &rest ARGS &key WEIGHTS AGGREGATE

Perform an intersection in DSTKEY over a number (N) of sorted sets at KEYS with optional WEIGHTS and AGGREGATE.

Package

redis

Source

commands.lisp (file)

Function: red-zlexcount KEY MIN MAX

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 min and max arguments have the same meaning as described for ZRANGEBYLEX.

Package

redis

Source

commands.lisp (file)

Function: red-zrange KEY START END &optional WITHSCORES

Return a range of elements from the sorted set at KEY.

Package

redis

Source

commands.lisp (file)

Function: red-zrangebyscore KEY MIN MAX &rest ARGS &key WITHSCORES LIMIT

Returns all the elements in the sorted set at KEY with a score between
MIN and MAX (including elements with score equal to MIN or MAX).
The elements are considered to be ordered from low to high scores.
The elements having the same score are returned in lexicographical order (this follows from a property of the sorted set implementation in Redis and does not involve further computation).
The optional LIMIT argument can be used to only get a range of the matching elements (similar to SELECT LIMIT offset, count in SQL).
The optional WITHSCORES argument makes the command return both the element and its score, instead of the element alone.

Package

redis

Source

commands.lisp (file)

Function: red-zrank KEY MEMBER

Return the rank (or index) or MEMBER in the sorted set at KEY, with scores being ordered from low to high.

Package

redis

Source

commands.lisp (file)

Function: red-zrem KEY &rest MEMBERS

Remove the specified MEMBER from the Set value at KEY.

Package

redis

Source

commands.lisp (file)

Function: red-zremrangebylex KEY MIN MAX

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 meaning of MIN and MAX are the same of the ZRANGEBYLEX command. Similarly, this command actually returns the same elements that ZRANGEBYLEX would return if called with the same min and max arguments.

Package

redis

Source

commands.lisp (file)

Function: red-zremrangebyrank KEY MIN MAX

Remove all the elements with rank >= MIN and rank <= MAX from the sorted set.

Package

redis

Source

commands.lisp (file)

Function: red-zremrangebyscore KEY MIN MAX

Remove all the elements with score >= MIN and score <= MAX from the sorted set.

Package

redis

Source

commands.lisp (file)

Function: red-zrevrange KEY START END &optional WITHSCORES

Return a range of elements from the sorted set at KEY, exactly like ZRANGE, but the sorted set is ordered in traversed in reverse order, from the greatest to the smallest score.

Package

redis

Source

commands.lisp (file)

Function: red-zrevrangebylex KEY MAX MIN &rest ARGS &key WITHSCORES LIMIT

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 max and min. Apart from the reversed ordering, ZREVRANGEBYLEX is similar to ZRANGEBYLEX.

Package

redis

Source

commands.lisp (file)

Function: red-zrevrangebyscore KEY MAX MIN &rest ARGS &key WITHSCORES LIMIT

Returns all the elements in the sorted set at KEY with a score between MAX and MIN (including elements with score equal to MAX or MIN).
In contrary to the default ordering of sorted sets, for this command the elements are considered to be ordered from high to low scores.
The elements having the same score are returned in reverse lexicographical order. Apart from the reversed ordering,
ZREVRANGEBYSCORE is similar to ZRANGEBYSCORE.

Package

redis

Source

commands.lisp (file)

Function: red-zrevrank KEY MEMBER

Return the rank (or index) or MEMBER in the sorted set at KEY, with scores being ordered from high to low.

Package

redis

Source

commands.lisp (file)

Function: red-zscan KEY CURSOR &rest ARGS &key MATCH COUNT

The ZSCAN command and the closely related commands SCAN, SSCAN and HSCAN are used in order to incrementally iterate over a collection of elements. ZSCAN iterates elements of Sorted Set types and their associated scores.

Package

redis

Source

commands.lisp (file)

Function: red-zscore KEY ELEMENT

Return the score associated with the specified ELEMENT of the sorted set at KEY.

Package

redis

Source

commands.lisp (file)

Function: red-zunionstore DSTKEY N KEYS &rest ARGS &key WEIGHTS AGGREGATE

Perform a union in DSTKEY over a number (N) of sorted sets at KEYS with optional WEIGHTS and AGGREGATE.

Package

redis

Source

commands.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.4 Generic functions

Generic Function: expect TYPE

Receive and process the reply of the given type from Redis server.

Package

redis

Source

redis.lisp (file)

Methods
Method: expect (TYPE (eql bytes))

Receive and process the reply of type BYTES.

Method: expect (TYPE (eql float))

Receive and process the reply of type FLOAT.

Method: expect (TYPE (eql list))
Method: expect (TYPE (eql end))
Method: expect (TYPE (eql pubsub))
Method: expect (TYPE (eql queued))

Receive and process the reply of type QUEUED.

Method: expect (TYPE (eql multi))

Receive and process the reply of type MULTI.

Method: expect (TYPE (eql bulk))

Receive and process the reply of type BULK.

Method: expect (TYPE (eql integer))

Receive and process the reply of type INTEGER.

Method: expect (TYPE (eql boolean))

Receive and process the reply of type BOOLEAN.

Method: expect (TYPE (eql inline))

Receive and process the reply of type INLINE.

Method: expect (TYPE (eql status))

Receive and process status reply, which is just a string, preceeded with +.

Method: expect (TYPE (eql anything))

Receive and process status reply, which is just a string, preceeded with +.

Method: expect TYPE around
Generic Function: redis-error-message CONDITION
Package

redis

Methods
Method: redis-error-message (CONDITION redis-error)
Source

redis.lisp (file)

Generic Function: tell CMD &rest ARGS

Send a command to Redis server over a socket connection.
CMD is the command name (a string or a symbol), and ARGS are its arguments (keyword arguments are also supported).

Package

redis

Source

redis.lisp (file)

Methods
Method: tell (CMD (eql zinterstore)) &rest ARGS
Source

commands.lisp (file)

Method: tell (CMD (eql zunionstore)) &rest ARGS
Source

commands.lisp (file)

Method: tell (CMD (eql zrevrangebylex)) &rest ARGS
Source

commands.lisp (file)

Method: tell (CMD (eql zrevrangebyscore)) &rest ARGS
Source

commands.lisp (file)

Method: tell (CMD (eql zrangebyscore)) &rest ARGS
Source

commands.lisp (file)

Method: tell (CMD (eql zrevrange)) &rest ARGS before
Source

commands.lisp (file)

Method: tell (CMD (eql zrange)) &rest ARGS before
Source

commands.lisp (file)

Method: tell (CMD (eql linsert)) &rest ARGS before
Source

commands.lisp (file)

Method: tell (CMD (eql bitcount)) &rest ARGS before
Source

commands.lisp (file)

Method: tell (CMD (eql zscan)) &rest ARGS
Source

commands.lisp (file)

Method: tell (CMD (eql hscan)) &rest ARGS
Source

commands.lisp (file)

Method: tell (CMD (eql sscan)) &rest ARGS
Source

commands.lisp (file)

Method: tell (CMD (eql scan)) &rest ARGS
Source

commands.lisp (file)

Method: tell (CMD (eql restore)) &rest ARGS
Source

commands.lisp (file)

Method: tell (CMD (eql sort)) &rest ARGS
Source

commands.lisp (file)

Method: tell CMD &rest ARGS
Method: tell CMD &rest ARGS after

Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.5 Conditions

Condition: redis-bad-reply ()

Redis protocol error is detected.

Package

redis

Source

redis.lisp (file)

Direct superclasses

redis-error (condition)

Condition: redis-connection-error ()

Conditions of this type are signaled when errors occur
that break the connection stream. They offer a :RECONNECT restart.

Package

redis

Source

redis.lisp (file)

Direct superclasses

redis-error (condition)

Condition: redis-error ()

Any Redis-related error.

Package

redis

Source

redis.lisp (file)

Direct superclasses

error (condition)

Direct subclasses
Direct methods
Direct slots
Slot: error
Initargs

:error

Initform

(quote nil)

Readers

redis-error-error (generic function)

Slot: message
Initargs

:message

Initform

(quote nil)

Readers

redis-error-message (generic function)

Condition: redis-error-reply ()

Error reply is received from Redis server.

Package

redis

Source

redis.lisp (file)

Direct superclasses

redis-error (condition)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.6 Classes

Class: redis-connection ()

Representation of a Redis connection.

Package

redis

Source

connection.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: host
Initargs

:host

Initform

#(127 0 0 1)

Readers

conn-host (generic function)

Slot: port
Initargs

:port

Initform

6379

Readers

conn-port (generic function)

Slot: auth
Initargs

:auth

Readers

conn-auth (generic function)

Slot: socket
Readers

conn-socket (generic function)

Writers

(setf conn-socket) (generic function)

Slot: stream
Readers

conn-stream (generic function)

Writers

(setf conn-stream) (generic function)


Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Special variables

Special Variable: *pipeline*

A list of expected results from the current pipeline.

Package

redis

Source

redis.lisp (file)

Special Variable: *pipelined*

Indicates, that commands are sent in pipelined mode.

Package

redis

Source

redis.lisp (file)

Special Variable: +utf8+
Package

redis

Source

connection.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Macros

Macro: read-bulk-reply &key POST-PROCESSING DECODE
Package

redis

Source

redis.lisp (file)

Macro: reconnect-restart-case (&key ERROR COMMENT) &body BODY

Signal the condition of type REDIS-CONNECTION-ERROR denoted by
the given ERROR and COMMENT offering a :RECONNECT restart to re-evaluate BODY.

Package

redis

Source

connection.lisp (file)

Macro: with-reconnect-restart &body BODY

When, during the execution of BODY, an error occurs that breaks the connection, a REDIS-CONNECTION-ERROR is signalled, offering a :RECONNECT restart that will re-evaluate body after the conenction is re-established.

Package

redis

Source

connection.lisp (file)

Macro: with-redis-in (LINE CHAR) &body BODY
Package

redis

Source

redis.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Functions

Function: append KEY VALUE

Append the specified string to the string stored at key.

Package

redis

Source

commands.lisp (file)

Function: auth PASS

Simple password authentication if enabled.

Package

redis

Source

commands.lisp (file)

Function: bgrewriteaof ()

Rewrite the append only file in background when it gets too big.

Package

redis

Source

commands.lisp (file)

Function: bgsave ()

Asynchronously save the DB on disk.

Package

redis

Source

commands.lisp (file)

Function: bitcount KEY &optional START END

Count set bits in a string at KEY
(with optional bounding indices START and END).

Package

redis

Source

commands.lisp (file)

Function: bitop OPERATION DESTKEY KEY &rest KEYS

Perform bitwise OPERATION between strings ar KEY and KEYS and store the result ad DSTKEY.

Package

redis

Source

commands.lisp (file)

Function: bitpos KEY BIT &optional START END

Return the position of the first bit set to 1 or 0 in a string.

Package

redis

Source

commands.lisp (file)

Function: blpop &rest KEYS-AND-TIMEOUT

Blocking LPOP.

Package

redis

Source

commands.lisp (file)

Function: brpop &rest KEYS-AND-TIMEOUT

Blocking RPOP.

Package

redis

Source

commands.lisp (file)

Function: brpoplpush SOURCE DESTINATION TIMEOUT

BRPOPLPUSH is the blocking variant of RPOPLPUSH. When source contains elements, this command behaves exactly like RPOPLPUSH. When source is empty, Redis will block the connection until another client pushes to it or until TIMEOUT is reached. A TIMEOUT of zero can be used to block indefinitely. See RPOPLPUSH for more information.

Package

redis

Source

commands.lisp (file)

Function: client-getname ()

The CLIENT GETNAME returns the name of the current connection as set by CLIENT SETNAME. Since every new connection starts without an associated name, if no name was assigned a null bulk reply is returned.

Package

redis

Source

commands.lisp (file)

Function: client-pause TIMEOUT

CLIENT PAUSE is a connections control command able to suspend all the Redis clients for the specified amount of time (in milliseconds).

Package

redis

Source

commands.lisp (file)

Function: client-setname CONNECTION-NAME

The CLIENT SETNAME command assigns a name to the current connection. The assigned name is displayed in the output of CLIENT LIST so that it is possible to identify the client that performed a given connection.

Package

redis

Source

commands.lisp (file)

Function: cluster-slots ()

CLUSTER SLOTS returns details about which cluster slots map to which Redis instances.

Package

redis

Source

commands.lisp (file)

Function: command ()

Returns Array reply of details about all Redis commands.
Cluster clients must be aware of key positions in commands so commands can go to matching instances, but Redis commands vary between accepting one key, multiple keys, or even multiple keys separated by other data.
You can use COMMAND to cache a mapping between commands and key positions for each command to enable exact routing of commands to cluster instances.

Package

redis

Source

commands.lisp (file)

Function: command-count ()

Returns Integer reply of number of total commands in this Redis server.

Package

redis

Source

commands.lisp (file)

Function: command-getkeys COMMAND-NAME &rest ARGS

Returns Array reply of keys from a full Redis command.
COMMAND GETKEYS is a helper command to let you find the keys from
a full Redis command.
COMMAND shows some commands as having movablekeys meaning the entire command must be parsed to discover storage or retrieval keys.
You can use COMMAND GETKEYS to discover key positions directly from how Redis parses the commands.

Package

redis

Source

commands.lisp (file)

Function: command-info COMMAND-NAME &rest ARGS

Returns Array reply of details about multiple Redis commands.
Same result format as COMMAND except you can specify which commands get returned.
If you request details about non-existing commands, their return position will be nil.

Package

redis

Source

commands.lisp (file)

Function: config-get PATTERN

Configure a Redis server at runtime: get glob PATTERN value.

Package

redis

Source

commands.lisp (file)

Function: config-resetstat ()

Resets the statistics reported by Redis using the INFO command.

Package

redis

Source

commands.lisp (file)

Function: config-rewrite ()

The CONFIG REWRITE command rewrites the redis.conf file the server
was started with, applying the minimal changes needed to make it reflecting the configuration currently used by the server, that may be different compared to the original one because of the use of the CONFIG SET command.

Package

redis

Source

commands.lisp (file)

Function: config-set PARAMETER VALUE

Configure a Redis server at runtime: set PARAMETER VALUE.

Package

redis

Source

commands.lisp (file)

Function: connection-open-p CONN

Is the socket of CONNECTION open?

Package

redis

Source

connection.lisp (file)

Function: dbsize ()

Return the number of keys in the current db.

Package

redis

Source

commands.lisp (file)

Function: decr KEY

Decrement the integer value of KEY.

Package

redis

Source

commands.lisp (file)

Function: decrby KEY DECREMENT

Decrement the integer value of KEY by DECREMENT.

Package

redis

Source

commands.lisp (file)

Function: del KEY &rest KEYS

Delete a key.

Package

redis

Source

commands.lisp (file)

Function: discard ()

Redis atomic transactions’ rollback.

Package

redis

Source

commands.lisp (file)

Function: dump KEY

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

Package

redis

Source

commands.lisp (file)

Function: echo MESSAGE

Returns message.

Package

redis

Source

commands.lisp (file)

Function: ensure-string OBJ
Package

redis

Source

redis.lisp (file)

Function: eval SCRIPT NUMKEYS &rest KEY-VALUES

Execute a Lua script server side.

Package

redis

Source

commands.lisp (file)

Function: evalsha SHA1 NUMKEYS &rest KEY-VALUES

Execute a stored Lua script server side.

Package

redis

Source

commands.lisp (file)

Function: exec ()

Redis atomic transactions’ commit.

Package

redis

Source

commands.lisp (file)

Function: exists KEY

Test if a key exists.

Package

redis

Source

commands.lisp (file)

Function: expire KEY SECS

Set a time to live in SECS on KEY.

Package

redis

Source

commands.lisp (file)

Function: expireat KEY TIMESTAMP

Set a timeout on KEY. After the timeout has expired, the key will automatically be deleted.
EXPIREAT has the same effect and semantic as EXPIRE, but instead of specifying the number of seconds representing the TTL, it takes
an absolute UNIX timestamp (seconds since January 1, 1970).
As in the case of EXPIRE command, if key is updated before the timeout has expired, then the timeout is removed as if the PERSIST command was invoked on KEY.

Package

redis

Source

commands.lisp (file)

Function: flushall ()

Remove all the keys from all the databases.

Package

redis

Source

commands.lisp (file)

Function: flushdb ()

Remove all the keys of the currently selected DB.

Package

redis

Source

commands.lisp (file)

Function: format-redis-number CHAR NUMBER

Write a prefix char and a number to the stream of the current connection. If *ECHOP-P* is not NIL, write that string to *ECHO-STREAM*, too.

Package

redis

Source

redis.lisp (file)

Function: format-redis-string STRING

Write a string and CRLF-terminator to the stream of the current connection. If *ECHOP-P* is not NIL, write that string to *ECHO-STREAM*, too.

Package

redis

Source

redis.lisp (file)

Function: get KEY

Return the string value of the key.

Package

redis

Source

commands.lisp (file)

Function: getbit KEY OFFSET

Returns the bit value at OFFSET in the string value stored at KEY.

Package

redis

Source

commands.lisp (file)

Function: getrange KEY OFFSET VALUE

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.

Package

redis

Source

commands.lisp (file)

Function: getset KEY VALUE

Set a key to a string returning the old value of the key.

Package

redis

Source

commands.lisp (file)

Function: hdel KEY FIELD

Remove the specified FIELD from a hash.

Package

redis

Source

commands.lisp (file)

Function: hexists KEY FIELD

Test for existence of a specified FIELD in a hash.

Package

redis

Source

commands.lisp (file)

Function: hget KEY FIELD

Retrieve the value of the specified hash FIELD.

Package

redis

Source

commands.lisp (file)

Function: hgetall KEY

Return all the fields and associated values in a hash.

Package

redis

Source

commands.lisp (file)

Function: hincrby KEY FIELD INTEGER

Increment the integer value of the hash at KEY on FIELD with INTEGER.

Package

redis

Source

commands.lisp (file)

Function: hincrbyfloat KEY FIELD INCREMENT

Increment the float value of the hash at KEY on FIELD with INCREMENT.

Package

redis

Source

commands.lisp (file)

Function: hkeys KEY

Return all the fields in a hash.

Package

redis

Source

commands.lisp (file)

Function: hlen KEY

Return the number of items in a hash.

Package

redis

Source

commands.lisp (file)

Function: hmget KEY FIELD &rest FIELDS

Get the values associated with the specified FIELDS in the hash stored at KEY.

Package

redis

Source

commands.lisp (file)

Function: hmset KEY &rest FIELDS-AND-VALUES

Set the hash FIELDS to their respective VALUES.

Package

redis

Source

commands.lisp (file)

Function: hscan KEY CURSOR &rest ARGS &key MATCH COUNT

The HSCAN command and the closely related commands SCAN, SSCAN and ZSCAN are used in order to incrementally iterate over a collection of elements. HSCAN iterates fields of Hash types and their associated values.

Package

redis

Source

commands.lisp (file)

Function: hset KEY FIELD VALUE

Set the hash FIELD to the specified VALUE. Creates the hash if needed.

Package

redis

Source

commands.lisp (file)

Function: hsetnx KEY FIELD VALUE

Set the hash FIELD to the specified VALUE, if the KEY doesn’t exist yet.

Package

redis

Source

commands.lisp (file)

Function: hvals KEY

Return all the values in a hash.

Package

redis

Source

commands.lisp (file)

Function: incr KEY

Increment the integer value of KEY.

Package

redis

Source

commands.lisp (file)

Function: incrby KEY INCREMENT

Increment the integer value of KEY by .

Package

redis

Source

commands.lisp (file)

Function: incrbyfloat KEY INCREMENT

Increment the float value of KEY by INCREMENT.

Package

redis

Source

commands.lisp (file)

Function: info &optional SECTION

Provide information and statistics about the server.

Package

redis

Source

commands.lisp (file)

Function: keys PATTERN

Return all the keys matching a given pattern.

Package

redis

Source

commands.lisp (file)

Function: lastsave ()

Return the UNIX time stamp of the last successfully saving of the dataset on disk.

Package

redis

Source

commands.lisp (file)

Function: lindex KEY INDEX

Return the element at index position from the List at key.

Package

redis

Source

commands.lisp (file)

Function: linsert KEY BEFORE/AFTER PIVOT VALUE

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. An error is returned when KEY exists, but does not hold a list value PIVOT.

Note: before/after can only have 2 values: :before or :after.

Package

redis

Source

commands.lisp (file)

Function: llen KEY

Return the length of the List value at key.

Package

redis

Source

commands.lisp (file)

Function: lpop KEY

Return and remove (atomically) the first element of the List at key.

Package

redis

Source

commands.lisp (file)

Function: lpush KEY VALUE

Append an element to the head of the list value at KEY.

Package

redis

Source

commands.lisp (file)

Function: lpushx KEY VALUE

Inserts value at the head of the list stored at KEY, only if KEY already exists and holds a list. In contrary to LPUSH, no operation will be performed when KEY does not yet exist.

Package

redis

Source

commands.lisp (file)

Function: lrange KEY START END

Return a range of elements from the List at key.

Package

redis

Source

commands.lisp (file)

Function: lrem KEY COUNT VALUE

Remove the first-N, last-N, or all the elements matching value from the List at key.

Package

redis

Source

commands.lisp (file)

Function: lset KEY INDEX VALUE

Set a new value as the element at index position of the List at key.

Package

redis

Source

commands.lisp (file)

Function: ltrim KEY START END

Trim the list at key to the specified range of elements.

Package

redis

Source

commands.lisp (file)

Function: mget &rest KEYS

Multi-get, return the strings values of the keys.

Package

redis

Source

commands.lisp (file)

Function: migrate HOST PORT KEY DESTINATION-DB TIMEOUT

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

Package

redis

Source

commands.lisp (file)

Function: move KEY DBINDEX

Move the key from the currently selected DB to the DB having as index dbindex.

Package

redis

Source

commands.lisp (file)

Function: mset &rest KEY-VALUE-PLIST

Set multiple keys to multiple values in a single atomic operation.

Package

redis

Source

commands.lisp (file)

Function: msetnx &rest KEY-VALUE-PLIST

Set multiple keys to multiple values in a single atomic operation if none of the keys already exist.

Package

redis

Source

commands.lisp (file)

Function: multi ()

Redis atomic transactions’ start.

Package

redis

Source

commands.lisp (file)

Function: object-encoding KEY

The OBJECT command allows to inspect the internals of Redis Objects
associated with keys. It is useful for debugging or to understand if your keys are using the specially encoded data types to save space. Your application may also use the information reported by the OBJECT command to implement application level key eviction policies when using Redis as a Cache.
OBJECT ENCODING <key> returns the kind of internal representation used in order to store the value associated with a key.

Package

redis

Source

commands.lisp (file)

Function: object-idletime KEY

The OBJECT command allows to inspect the internals of Redis Objects
associated with keys. It is useful for debugging or to understand if your keys are using the specially encoded data types to save space. Your application may also use the information reported by the OBJECT command to implement application level key eviction policies when using Redis as a Cache.
OBJECT IDLETIME <key> returns the number of seconds since the object stored at the specified key is idle (not requested by read or write operations). While the value is returned in seconds the actual resolution of this timer is 10 seconds, but may vary in future implementations.

Package

redis

Source

commands.lisp (file)

Function: object-refcount KEY

The OBJECT command allows to inspect the internals of Redis Objects
associated with keys. It is useful for debugging or to understand if your keys are using the specially encoded data types to save space. Your application may also use the information reported by the OBJECT command to implement application level key eviction policies when using Redis as a Cache.
OBJECT REFCOUNT <key> returns the number of references of the value associated with the specified key.

Package

redis

Source

commands.lisp (file)

Function: parse-float FLOAT-STRING &key START END RADIX JUNK-ALLOWED TYPE DECIMAL-CHARACTER
Package

redis

Source

float.lisp (file)

Function: persist KEY

Remove the existing timeout on KEY.

Package

redis

Source

commands.lisp (file)

Function: pexpire KEY MILLISECONDS

Set a KEY’s time to live in MILLISECONDS.

Package

redis

Source

commands.lisp (file)

Function: pexpireat KEY MILLISECONDS-TIMESTAMP

Set the expiration for a KEY as a Unix timestamp specified in milliseconds.

Package

redis

Source

commands.lisp (file)

Function: pfadd KEY ELEMENT &rest ELEMENTS

Adds all the element arguments to the HyperLogLog data structure stored
at the variable name specified as first argument.
As a side effect of this command the HyperLogLog internals may be updated to reflect a different estimation of the number of unique items added so far (the cardinality of the set).
If the approximated cardinality estimated by the HyperLogLog changed after executing the command, PFADD returns 1, otherwise 0 is returned.
The command automatically creates an empty HyperLogLog structure (that is, a Redis String of a specified length and with a given encoding) if
the specified key does not exist.
To call the command without elements but just the variable name is valid, this will result into no operation performed if the variable already exists, or just the creation of the data structure if the key does not exist
(in the latter case 1 is returned).

Package

redis

Source

commands.lisp (file)

Function: pfcount KEY &rest KEYS

When called with a single key, returns the approximated cardinality computed by the HyperLogLog data structure stored at the specified variable,
which is 0 if the variable does not exist.
When called with multiple keys, 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.
The HyperLogLog data structure can be used in order to count unique elements in a set using just a small constant amount of memory, specifically 12k bytes for every HyperLogLog (plus a few bytes for the key itself).
The returned cardinality of the observed set is not exact, but approximated with a standard error of 0.81%.
For example, in order to take the count of all the unique search queries performed in a day, a program needs to call PFADD every time a query is processed. The estimated number of unique queries can be retrieved with PFCOUNT at any time.
Note: as a side effect of calling this function, it is possible that
the HyperLogLog is modified, since the last 8 bytes encode the latest computed cardinality for caching purposes. So PFCOUNT is technically
a write command.

Package

redis

Source

commands.lisp (file)

Function: pfmerge DESTKEY SOURCEKEY &rest SOURCEKEYS

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 computed merged HyperLogLog is set to the destination variable, which is created if does not exist (defaulting to an empty HyperLogLog).

Package

redis

Source

commands.lisp (file)

Function: ping ()

Ping server.

Package

redis

Source

commands.lisp (file)

Function: psubscribe &rest PATTERNS

Redis Public/Subscribe messaging paradigm implementation.

Package

redis

Source

commands.lisp (file)

Function: pttl KEY

Get the time to live in milliseconds of KEY.

Package

redis

Source

commands.lisp (file)

Function: publish CHANNEL MESSAGE

Redis Public/Subscribe messaging paradigm implementation.

Package

redis

Source

commands.lisp (file)

Function: punsubscribe &rest PATTERNS

Redis Public/Subscribe messaging paradigm implementation.

Package

redis

Source

commands.lisp (file)

Function: quit ()

Close the connection.

Package

redis

Source

commands.lisp (file)

Function: radix-values RADIX
Package

redis

Source

float.lisp (file)

Function: randomkey ()

Return a random key from the key space.

Package

redis

Source

commands.lisp (file)

Function: rename OLDNAME NEWNAME

Rename the old key in the new one, destroing the newname key if it already exists.

Package

redis

Source

commands.lisp (file)

Function: renamenx OLDNAME NEWNAME

Rename the old key in the new one, if the newname key does not already exist.

Package

redis

Source

commands.lisp (file)

Function: reopen-connection CONN

Close and reopen CONN.

Package

redis

Source

connection.lisp (file)

Function: restore KEY TTL SERIALIZED-VALUE

Create a KEY using the provided SERIALIZED-VALUE, previously obtained using DUMP.

Package

redis

Source

commands.lisp (file)

Function: role ()

Provide information on the role of a Redis instance in the context
of replication, by returning if the instance is currently a master, slave, or sentinel. The command also returns additional information about the state of the replication (if the role is master or slave) or the list of monitored master names (if the role is sentinel).

Package

redis

Source

commands.lisp (file)

Function: rpop KEY

Return and remove (atomically) the last element of the List at key.

Package

redis

Source

commands.lisp (file)

Function: rpoplpush SOURCE DESTINATION

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.
For example: consider SOURCE holding the list a,b,c, and DESTINATION holding the list x,y,z. Executing RPOPLPUSH results in SOURCE holding a,b and DESTINATION holding c,x,y,z.
If SOURCE does not exist, the value nil is returned and no operation is performed. If SOURCE and DESTINATION are the same, the operation is equivalent to removing the last element from the list and pushing it as first element of the list, so it can be considered as a list rotation command.

Package

redis

Source

commands.lisp (file)

Function: rpush KEY VALUE

Append an element to the tail of the list value at KEY.

Package

redis

Source

commands.lisp (file)

Function: rpushx KEY VALUE

Inserts value at the tail of the list stored at KEY, only if KEY already exists and holds a list. In contrary to RPUSH, no operation will be performed when KEY does not yet exist.

Package

redis

Source

commands.lisp (file)

Function: sadd KEY &rest MEMBERS

Add the specified member to the Set value at key.

Package

redis

Source

commands.lisp (file)

Function: save ()

Synchronously save the DB on disk.

Package

redis

Source

commands.lisp (file)

Function: scan CURSOR &rest ARGS &key MATCH COUNT

The SCAN command and the closely related commands SSCAN, HSCAN and ZSCAN are used in order to incrementally iterate over a collection of elements. SCAN iterates the set of keys in the currently selected Redis database.

Package

redis

Source

commands.lisp (file)

Function: scard KEY

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

Package

redis

Source

commands.lisp (file)

Function: script-exists SCRIPT &rest SCRIPTS

Check existence of scripts in the script cache.

Package

redis

Source

commands.lisp (file)

Function: script-flush ()

Remove all the scripts from the script cache.

Package

redis

Source

commands.lisp (file)

Function: script-kill ()

Kill the script currently in execution.

Package

redis

Source

commands.lisp (file)

Function: script-load SCRIPT

Load the specified Lua script into the script cache.

Package

redis

Source

commands.lisp (file)

Function: sdiff &rest KEYS

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

Package

redis

Source

commands.lisp (file)

Function: sdiffstore DSTKEY &rest KEYS

Compute the difference between the Set key1 and all the Sets key2, ..., keyN, and store the resulting Set at dstkey.

Package

redis

Source

commands.lisp (file)

Function: select INDEX

Select the DB having the specified index.

Package

redis

Source

commands.lisp (file)

Function: set KEY VALUE

Set a key to a string value.

Package

redis

Source

commands.lisp (file)

Function: setbit KEY OFFSET VALUE

Sets or clears the bit at OFFSET in the string value stored at KEY.

Package

redis

Source

commands.lisp (file)

Function: setex KEY TIME VALUE

Set KEY to hold the string VALUE and set KEY to timeout after a given number of seconds. This command is equivalent to executing the following commands: SET mykey value
EXPIRE mykey seconds
SETEX is atomic, and can be reproduced by using the previous two commands inside an MULTI/EXEC block. It is provided as a faster alternative to the given sequence of operations, because this operation is very common when Redis is used as a cache.
An error is returned when seconds is invalid.

Package

redis

Source

commands.lisp (file)

Function: setnx KEY VALUE

Set a key to a string value if the key does not exist.

Package

redis

Source

commands.lisp (file)

Function: setrange KEY OFFSET VALUE

Overwrites part of the string stored at KEY, starting at the specified OFFSET, for the entire length of VALUE. If the OFFSET is larger than the current length of the string at KEY, the string is padded with zero-bytes to make OFFSET fit. Non-existing keys are considered as empty strings, so this command will make sure it holds a string large enough to be able to set value at OFFSET. Note that the maximum OFFSET that you can set is 229^-1 (536870911), as Redis Strings are limited to 512 megabytes.

Package

redis

Source

commands.lisp (file)

Function: shutdown ()

Synchronously save the DB on disk, then shutdown the server.

Package

redis

Source

commands.lisp (file)

Function: sinter &rest KEYS

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

Package

redis

Source

commands.lisp (file)

Function: sinterstore DSTKEY &rest KEYS

Compute the intersection between the Sets stored at key1, key2, ..., keyN, and store the resulting Set at dstkey.

Package

redis

Source

commands.lisp (file)

Function: sismember KEY MEMBER

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

Package

redis

Source

commands.lisp (file)

Function: slaveof HOSTNAME PORT

Change the replication settings.

Package

redis

Source

commands.lisp (file)

Function: slowlog SUBCOMMAND &optional ARGUMENT

Manages the Redis slow queries log.

Package

redis

Source

commands.lisp (file)

Function: smembers KEY

Return all the members of the Set value at key.

Package

redis

Source

commands.lisp (file)

Function: smove SRCKEY DSTKEY MEMBER

Move the specified member from one Set to another atomically.

Package

redis

Source

commands.lisp (file)

Function: sort KEY &rest ARGS &key BY START END GET DESC ALPHA STORE

Sort a Set or a List accordingly to the specified parameters.

Package

redis

Source

commands.lisp (file)

Function: spop KEY

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

Package

redis

Source

commands.lisp (file)

Function: srandmember KEY &optional COUNT

Get one or COUNT random members from a set at KEY.
When called with the additional count argument,
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.

Package

redis

Source

commands.lisp (file)

Function: srem KEY &rest MEMBERS

Remove the specified member from the Set value at key.

Package

redis

Source

commands.lisp (file)

Function: sscan KEY CURSOR &rest ARGS &key MATCH COUNT

The SCAN command and the closely related commands SCAN, HSCAN and ZSCAN are used in order to incrementally iterate over a collection of elements. SSCAN iterates elements of Sets types.

Package

redis

Source

commands.lisp (file)

Function: strlen KEY

Returns the length of the string value stored at KEY.

Package

redis

Source

commands.lisp (file)

Function: subscribe &rest CHANNELS

Redis Public/Subscribe messaging paradigm implementation.

Package

redis

Source

commands.lisp (file)

Function: substr KEY START END

Return a substring out of a larger string.
Warning: left for backwards compatibility. It is now called: GETRANGE.

Package

redis

Source

commands.lisp (file)

Function: sunion &rest KEYS

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

Package

redis

Source

commands.lisp (file)

Function: sunionstore DSTKEY &rest KEYS

Compute the union between the Sets stored at key1, key2, ..., keyN, and store the resulting Set at dstkey.

Package

redis

Source

commands.lisp (file)

Function: sync ()

Synchronize with slave.

Package

redis

Source

commands.lisp (file)

Function: time ()

The TIME command returns the current server time as a two items lists: a Unix timestamp and the amount of microseconds already elapsed in the current second.
Basically the interface is very similar to the one of the gettimeofday system call.

Package

redis

Source

commands.lisp (file)

Function: ttl KEY

Get the time to live in seconds of KEY.

Package

redis

Source

commands.lisp (file)

Function: type KEY

Return the type of the value stored at key.

Package

redis

Source

commands.lisp (file)

Function: unsubscribe &rest CHANNELS

Redis Public/Subscribe messaging paradigm implementation.

Package

redis

Source

commands.lisp (file)

Function: unwatch ()

Flushes all the previously watched keys for a transaction.
If you call EXEC or DISCARD, there’s no need to manually call UNWATCH.

Package

redis

Source

commands.lisp (file)

Function: watch KEY &rest KEYS

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

Package

redis

Source

commands.lisp (file)

Function: zadd KEY &rest SCORE-MEMBER-PAIRS

Add the specified MEMBER to the Set value at KEY or update the SCORE if it already exist. If nil is returned, the element already existed in the set. Just the score was updated.

Package

redis

Source

commands.lisp (file)

Function: zcard KEY

Return the cardinality (number of elements) of the sorted set at KEY.

Package

redis

Source

commands.lisp (file)

Function: zcount KEY MIN MAX

Returns the number of elements in the sorted set at KEY with a score between MIN and MAX.

Package

redis

Source

commands.lisp (file)

Function: zincrby KEY INCREMENT MEMBER

If the MEMBER already exists increment its score by INCREMENT, otherwise add the member setting INCREMENT as score.

Package

redis

Source

commands.lisp (file)

Function: zinterstore DSTKEY N KEYS &rest ARGS &key WEIGHTS AGGREGATE

Perform an intersection in DSTKEY over a number (N) of sorted sets at KEYS with optional WEIGHTS and AGGREGATE.

Package

redis

Source

commands.lisp (file)

Function: zlexcount KEY MIN MAX

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 min and max arguments have the same meaning as described for ZRANGEBYLEX.

Package

redis

Source

commands.lisp (file)

Function: zrange KEY START END &optional WITHSCORES

Return a range of elements from the sorted set at KEY.

Package

redis

Source

commands.lisp (file)

Function: zrangebyscore KEY MIN MAX &rest ARGS &key WITHSCORES LIMIT

Returns all the elements in the sorted set at KEY with a score between
MIN and MAX (including elements with score equal to MIN or MAX).
The elements are considered to be ordered from low to high scores.
The elements having the same score are returned in lexicographical order (this follows from a property of the sorted set implementation in Redis and does not involve further computation).
The optional LIMIT argument can be used to only get a range of the matching elements (similar to SELECT LIMIT offset, count in SQL).
The optional WITHSCORES argument makes the command return both the element and its score, instead of the element alone.

Package

redis

Source

commands.lisp (file)

Function: zrank KEY MEMBER

Return the rank (or index) or MEMBER in the sorted set at KEY, with scores being ordered from low to high.

Package

redis

Source

commands.lisp (file)

Function: zrem KEY &rest MEMBERS

Remove the specified MEMBER from the Set value at KEY.

Package

redis

Source

commands.lisp (file)

Function: zremrangebylex KEY MIN MAX

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 meaning of MIN and MAX are the same of the ZRANGEBYLEX command. Similarly, this command actually returns the same elements that ZRANGEBYLEX would return if called with the same min and max arguments.

Package

redis

Source

commands.lisp (file)

Function: zremrangebyrank KEY MIN MAX

Remove all the elements with rank >= MIN and rank <= MAX from the sorted set.

Package

redis

Source

commands.lisp (file)

Function: zremrangebyscore KEY MIN MAX

Remove all the elements with score >= MIN and score <= MAX from the sorted set.

Package

redis

Source

commands.lisp (file)

Function: zrevrange KEY START END &optional WITHSCORES

Return a range of elements from the sorted set at KEY, exactly like ZRANGE, but the sorted set is ordered in traversed in reverse order, from the greatest to the smallest score.

Package

redis

Source

commands.lisp (file)

Function: zrevrangebylex KEY MAX MIN &rest ARGS &key WITHSCORES LIMIT

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 max and min. Apart from the reversed ordering, ZREVRANGEBYLEX is similar to ZRANGEBYLEX.

Package

redis

Source

commands.lisp (file)

Function: zrevrangebyscore KEY MAX MIN &rest ARGS &key WITHSCORES LIMIT

Returns all the elements in the sorted set at KEY with a score between MAX and MIN (including elements with score equal to MAX or MIN).
In contrary to the default ordering of sorted sets, for this command the elements are considered to be ordered from high to low scores.
The elements having the same score are returned in reverse lexicographical order. Apart from the reversed ordering,
ZREVRANGEBYSCORE is similar to ZRANGEBYSCORE.

Package

redis

Source

commands.lisp (file)

Function: zrevrank KEY MEMBER

Return the rank (or index) or MEMBER in the sorted set at KEY, with scores being ordered from high to low.

Package

redis

Source

commands.lisp (file)

Function: zscan KEY CURSOR &rest ARGS &key MATCH COUNT

The ZSCAN command and the closely related commands SCAN, SSCAN and HSCAN are used in order to incrementally iterate over a collection of elements. ZSCAN iterates elements of Sorted Set types and their associated scores.

Package

redis

Source

commands.lisp (file)

Function: zscore KEY ELEMENT

Return the score associated with the specified ELEMENT of the sorted set at KEY.

Package

redis

Source

commands.lisp (file)

Function: zunionstore DSTKEY N KEYS &rest ARGS &key WEIGHTS AGGREGATE

Perform a union in DSTKEY over a number (N) of sorted sets at KEYS with optional WEIGHTS and AGGREGATE.

Package

redis

Source

commands.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.4 Generic functions

Generic Function: conn-auth OBJECT
Package

redis

Methods
Method: conn-auth (REDIS-CONNECTION redis-connection)

automatically generated reader method

Source

connection.lisp (file)

Generic Function: conn-host OBJECT
Package

redis

Methods
Method: conn-host (REDIS-CONNECTION redis-connection)

automatically generated reader method

Source

connection.lisp (file)

Generic Function: conn-port OBJECT
Package

redis

Methods
Method: conn-port (REDIS-CONNECTION redis-connection)

automatically generated reader method

Source

connection.lisp (file)

Generic Function: conn-socket OBJECT
Generic Function: (setf conn-socket) NEW-VALUE OBJECT
Package

redis

Methods
Method: conn-socket (REDIS-CONNECTION redis-connection)

automatically generated reader method

Source

connection.lisp (file)

Method: (setf conn-socket) NEW-VALUE (REDIS-CONNECTION redis-connection)

automatically generated writer method

Source

connection.lisp (file)

Generic Function: conn-stream OBJECT
Generic Function: (setf conn-stream) NEW-VALUE OBJECT
Package

redis

Methods
Method: conn-stream (REDIS-CONNECTION redis-connection)

automatically generated reader method

Source

connection.lisp (file)

Method: (setf conn-stream) NEW-VALUE (REDIS-CONNECTION redis-connection)

automatically generated writer method

Source

connection.lisp (file)

Generic Function: redis-error-error CONDITION
Package

redis

Methods
Method: redis-error-error (CONDITION redis-error)
Source

redis.lisp (file)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   C   F   L  
Index Entry  Section

C
cl-redis.asd: The cl-redis<dot>asd file
cl-redis/commands.lisp: The cl-redis/commands<dot>lisp file
cl-redis/connection.lisp: The cl-redis/connection<dot>lisp file
cl-redis/float.lisp: The cl-redis/float<dot>lisp file
cl-redis/package.lisp: The cl-redis/package<dot>lisp file
cl-redis/redis.lisp: The cl-redis/redis<dot>lisp file

F
File, Lisp, cl-redis.asd: The cl-redis<dot>asd file
File, Lisp, cl-redis/commands.lisp: The cl-redis/commands<dot>lisp file
File, Lisp, cl-redis/connection.lisp: The cl-redis/connection<dot>lisp file
File, Lisp, cl-redis/float.lisp: The cl-redis/float<dot>lisp file
File, Lisp, cl-redis/package.lisp: The cl-redis/package<dot>lisp file
File, Lisp, cl-redis/redis.lisp: The cl-redis/redis<dot>lisp file

L
Lisp File, cl-redis.asd: The cl-redis<dot>asd file
Lisp File, cl-redis/commands.lisp: The cl-redis/commands<dot>lisp file
Lisp File, cl-redis/connection.lisp: The cl-redis/connection<dot>lisp file
Lisp File, cl-redis/float.lisp: The cl-redis/float<dot>lisp file
Lisp File, cl-redis/package.lisp: The cl-redis/package<dot>lisp file
Lisp File, cl-redis/redis.lisp: The cl-redis/redis<dot>lisp file

Jump to:   C   F   L  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (  
A   B   C   D   E   F   G   H   I   K   L   M   O   P   Q   R   S   T   U   W   Z  
Index Entry  Section

(
(setf conn-socket): Internal generic functions
(setf conn-socket): Internal generic functions
(setf conn-stream): Internal generic functions
(setf conn-stream): Internal generic functions

A
append: Internal functions
auth: Internal functions

B
bgrewriteaof: Internal functions
bgsave: Internal functions
bitcount: Internal functions
bitop: Internal functions
bitpos: Internal functions
blpop: Internal functions
brpop: Internal functions
brpoplpush: Internal functions

C
client-getname: Internal functions
client-pause: Internal functions
client-setname: Internal functions
close-connection: Exported functions
cluster-slots: Internal functions
command: Internal functions
command-count: Internal functions
command-getkeys: Internal functions
command-info: Internal functions
config-get: Internal functions
config-resetstat: Internal functions
config-rewrite: Internal functions
config-set: Internal functions
conn-auth: Internal generic functions
conn-auth: Internal generic functions
conn-host: Internal generic functions
conn-host: Internal generic functions
conn-port: Internal generic functions
conn-port: Internal generic functions
conn-socket: Internal generic functions
conn-socket: Internal generic functions
conn-stream: Internal generic functions
conn-stream: Internal generic functions
connect: Exported functions
connected-p: Exported functions
connection-open-p: Internal functions

D
dbsize: Internal functions
decr: Internal functions
decrby: Internal functions
def-cmd: Exported macros
def-expect-method: Exported macros
del: Internal functions
discard: Internal functions
disconnect: Exported functions
dump: Internal functions

E
echo: Internal functions
ensure-string: Internal functions
eval: Internal functions
evalsha: Internal functions
exec: Internal functions
exists: Internal functions
expect: Exported generic functions
expect: Exported generic functions
expect: Exported generic functions
expect: Exported generic functions
expect: Exported generic functions
expect: Exported generic functions
expect: Exported generic functions
expect: Exported generic functions
expect: Exported generic functions
expect: Exported generic functions
expect: Exported generic functions
expect: Exported generic functions
expect: Exported generic functions
expect: Exported generic functions
expect: Exported generic functions
expire: Internal functions
expireat: Internal functions

F
flushall: Internal functions
flushdb: Internal functions
format-redis-number: Internal functions
format-redis-string: Internal functions
Function, append: Internal functions
Function, auth: Internal functions
Function, bgrewriteaof: Internal functions
Function, bgsave: Internal functions
Function, bitcount: Internal functions
Function, bitop: Internal functions
Function, bitpos: Internal functions
Function, blpop: Internal functions
Function, brpop: Internal functions
Function, brpoplpush: Internal functions
Function, client-getname: Internal functions
Function, client-pause: Internal functions
Function, client-setname: Internal functions
Function, close-connection: Exported functions
Function, cluster-slots: Internal functions
Function, command: Internal functions
Function, command-count: Internal functions
Function, command-getkeys: Internal functions
Function, command-info: Internal functions
Function, config-get: Internal functions
Function, config-resetstat: Internal functions
Function, config-rewrite: Internal functions
Function, config-set: Internal functions
Function, connect: Exported functions
Function, connected-p: Exported functions
Function, connection-open-p: Internal functions
Function, dbsize: Internal functions
Function, decr: Internal functions
Function, decrby: Internal functions
Function, del: Internal functions
Function, discard: Internal functions
Function, disconnect: Exported functions
Function, dump: Internal functions
Function, echo: Internal functions
Function, ensure-string: Internal functions
Function, eval: Internal functions
Function, evalsha: Internal functions
Function, exec: Internal functions
Function, exists: Internal functions
Function, expire: Internal functions
Function, expireat: Internal functions
Function, flushall: Internal functions
Function, flushdb: Internal functions
Function, format-redis-number: Internal functions
Function, format-redis-string: Internal functions
Function, get: Internal functions
Function, getbit: Internal functions
Function, getrange: Internal functions
Function, getset: Internal functions
Function, hdel: Internal functions
Function, hexists: Internal functions
Function, hget: Internal functions
Function, hgetall: Internal functions
Function, hincrby: Internal functions
Function, hincrbyfloat: Internal functions
Function, hkeys: Internal functions
Function, hlen: Internal functions
Function, hmget: Internal functions
Function, hmset: Internal functions
Function, hscan: Internal functions
Function, hset: Internal functions
Function, hsetnx: Internal functions
Function, hvals: Internal functions
Function, incr: Internal functions
Function, incrby: Internal functions
Function, incrbyfloat: Internal functions
Function, info: Internal functions
Function, keys: Internal functions
Function, lastsave: Internal functions
Function, lindex: Internal functions
Function, linsert: Internal functions
Function, llen: Internal functions
Function, lpop: Internal functions
Function, lpush: Internal functions
Function, lpushx: Internal functions
Function, lrange: Internal functions
Function, lrem: Internal functions
Function, lset: Internal functions
Function, ltrim: Internal functions
Function, mget: Internal functions
Function, migrate: Internal functions
Function, move: Internal functions
Function, mset: Internal functions
Function, msetnx: Internal functions
Function, multi: Internal functions
Function, object-encoding: Internal functions
Function, object-idletime: Internal functions
Function, object-refcount: Internal functions
Function, open-connection: Exported functions
Function, parse-float: Internal functions
Function, persist: Internal functions
Function, pexpire: Internal functions
Function, pexpireat: Internal functions
Function, pfadd: Internal functions
Function, pfcount: Internal functions
Function, pfmerge: Internal functions
Function, ping: Internal functions
Function, psubscribe: Internal functions
Function, pttl: Internal functions
Function, publish: Internal functions
Function, punsubscribe: Internal functions
Function, quit: Internal functions
Function, radix-values: Internal functions
Function, randomkey: Internal functions
Function, reconnect: Exported functions
Function, red-append: Exported functions
Function, red-auth: Exported functions
Function, red-bgrewriteaof: Exported functions
Function, red-bgsave: Exported functions
Function, red-bitcount: Exported functions
Function, red-bitop: Exported functions
Function, red-bitpos: Exported functions
Function, red-blpop: Exported functions
Function, red-brpop: Exported functions
Function, red-brpoplpush: Exported functions
Function, red-client-getname: Exported functions
Function, red-client-pause: Exported functions
Function, red-client-setname: Exported functions
Function, red-cluster-slots: Exported functions
Function, red-command: Exported functions
Function, red-command-count: Exported functions
Function, red-command-getkeys: Exported functions
Function, red-command-info: Exported functions
Function, red-config-get: Exported functions
Function, red-config-resetstat: Exported functions
Function, red-config-rewrite: Exported functions
Function, red-config-set: Exported functions
Function, red-dbsize: Exported functions
Function, red-decr: Exported functions
Function, red-decrby: Exported functions
Function, red-del: Exported functions
Function, red-discard: Exported functions
Function, red-dump: Exported functions
Function, red-echo: Exported functions
Function, red-eval: Exported functions
Function, red-evalsha: Exported functions
Function, red-exec: Exported functions
Function, red-exists: Exported functions
Function, red-expire: Exported functions
Function, red-expireat: Exported functions
Function, red-flushall: Exported functions
Function, red-flushdb: Exported functions
Function, red-get: Exported functions
Function, red-getbit: Exported functions
Function, red-getrange: Exported functions
Function, red-getset: Exported functions
Function, red-hdel: Exported functions
Function, red-hexists: Exported functions
Function, red-hget: Exported functions
Function, red-hgetall: Exported functions
Function, red-hincrby: Exported functions
Function, red-hincrbyfloat: Exported functions
Function, red-hkeys: Exported functions
Function, red-hlen: Exported functions
Function, red-hmget: Exported functions
Function, red-hmset: Exported functions
Function, red-hscan: Exported functions
Function, red-hset: Exported functions
Function, red-hsetnx: Exported functions
Function, red-hvals: Exported functions
Function, red-incr: Exported functions
Function, red-incrby: Exported functions
Function, red-incrbyfloat: Exported functions
Function, red-info: Exported functions
Function, red-keys: Exported functions
Function, red-lastsave: Exported functions
Function, red-lindex: Exported functions
Function, red-linsert: Exported functions
Function, red-llen: Exported functions
Function, red-lpop: Exported functions
Function, red-lpush: Exported functions
Function, red-lpushx: Exported functions
Function, red-lrange: Exported functions
Function, red-lrem: Exported functions
Function, red-lset: Exported functions
Function, red-ltrim: Exported functions
Function, red-mget: Exported functions
Function, red-migrate: Exported functions
Function, red-move: Exported functions
Function, red-mset: Exported functions
Function, red-msetnx: Exported functions
Function, red-multi: Exported functions
Function, red-object-encoding: Exported functions
Function, red-object-idletime: Exported functions
Function, red-object-refcount: Exported functions
Function, red-persist: Exported functions
Function, red-pexpire: Exported functions
Function, red-pexpireat: Exported functions
Function, red-pfadd: Exported functions
Function, red-pfcount: Exported functions
Function, red-pfmerge: Exported functions
Function, red-ping: Exported functions
Function, red-psubscribe: Exported functions
Function, red-pttl: Exported functions
Function, red-publish: Exported functions
Function, red-punsubscribe: Exported functions
Function, red-quit: Exported functions
Function, red-randomkey: Exported functions
Function, red-rename: Exported functions
Function, red-renamenx: Exported functions
Function, red-restore: Exported functions
Function, red-role: Exported functions
Function, red-rpop: Exported functions
Function, red-rpoplpush: Exported functions
Function, red-rpush: Exported functions
Function, red-rpushx: Exported functions
Function, red-sadd: Exported functions
Function, red-save: Exported functions
Function, red-scan: Exported functions
Function, red-scard: Exported functions
Function, red-script-exists: Exported functions
Function, red-script-flush: Exported functions
Function, red-script-kill: Exported functions
Function, red-script-load: Exported functions
Function, red-sdiff: Exported functions
Function, red-sdiffstore: Exported functions
Function, red-select: Exported functions
Function, red-set: Exported functions
Function, red-setbit: Exported functions
Function, red-setex: Exported functions
Function, red-setnx: Exported functions
Function, red-setrange: Exported functions
Function, red-shutdown: Exported functions
Function, red-sinter: Exported functions
Function, red-sinterstore: Exported functions
Function, red-sismember: Exported functions
Function, red-slaveof: Exported functions
Function, red-slowlog: Exported functions
Function, red-smembers: Exported functions
Function, red-smove: Exported functions
Function, red-sort: Exported functions
Function, red-spop: Exported functions
Function, red-srandmember: Exported functions
Function, red-srem: Exported functions
Function, red-sscan: Exported functions
Function, red-strlen: Exported functions
Function, red-subscribe: Exported functions
Function, red-substr: Exported functions
Function, red-sunion: Exported functions
Function, red-sunionstore: Exported functions
Function, red-sync: Exported functions
Function, red-time: Exported functions
Function, red-ttl: Exported functions
Function, red-type: Exported functions
Function, red-unsubscribe: Exported functions
Function, red-unwatch: Exported functions
Function, red-watch: Exported functions
Function, red-zadd: Exported functions
Function, red-zcard: Exported functions
Function, red-zcount: Exported functions
Function, red-zincrby: Exported functions
Function, red-zinterstore: Exported functions
Function, red-zlexcount: Exported functions
Function, red-zrange: Exported functions
Function, red-zrangebyscore: Exported functions
Function, red-zrank: Exported functions
Function, red-zrem: Exported functions
Function, red-zremrangebylex: Exported functions
Function, red-zremrangebyrank: Exported functions
Function, red-zremrangebyscore: Exported functions
Function, red-zrevrange: Exported functions
Function, red-zrevrangebylex: Exported functions
Function, red-zrevrangebyscore: Exported functions
Function, red-zrevrank: Exported functions
Function, red-zscan: Exported functions
Function, red-zscore: Exported functions
Function, red-zunionstore: Exported functions
Function, rename: Internal functions
Function, renamenx: Internal functions
Function, reopen-connection: Internal functions
Function, restore: Internal functions
Function, role: Internal functions
Function, rpop: Internal functions
Function, rpoplpush: Internal functions
Function, rpush: Internal functions
Function, rpushx: Internal functions
Function, sadd: Internal functions
Function, save: Internal functions
Function, scan: Internal functions
Function, scard: Internal functions
Function, script-exists: Internal functions
Function, script-flush: Internal functions
Function, script-kill: Internal functions
Function, script-load: Internal functions
Function, sdiff: Internal functions
Function, sdiffstore: Internal functions
Function, select: Internal functions
Function, set: Internal functions
Function, setbit: Internal functions
Function, setex: Internal functions
Function, setnx: Internal functions
Function, setrange: Internal functions
Function, shutdown: Internal functions
Function, sinter: Internal functions
Function, sinterstore: Internal functions
Function, sismember: Internal functions
Function, slaveof: Internal functions
Function, slowlog: Internal functions
Function, smembers: Internal functions
Function, smove: Internal functions
Function, sort: Internal functions
Function, spop: Internal functions
Function, srandmember: Internal functions
Function, srem: Internal functions
Function, sscan: Internal functions
Function, strlen: Internal functions
Function, subscribe: Internal functions
Function, substr: Internal functions
Function, sunion: Internal functions
Function, sunionstore: Internal functions
Function, sync: Internal functions
Function, time: Internal functions
Function, ttl: Internal functions
Function, type: Internal functions
Function, unsubscribe: Internal functions
Function, unwatch: Internal functions
Function, watch: Internal functions
Function, zadd: Internal functions
Function, zcard: Internal functions
Function, zcount: Internal functions
Function, zincrby: Internal functions
Function, zinterstore: Internal functions
Function, zlexcount: Internal functions
Function, zrange: Internal functions
Function, zrangebyscore: Internal functions
Function, zrank: Internal functions
Function, zrem: Internal functions
Function, zremrangebylex: Internal functions
Function, zremrangebyrank: Internal functions
Function, zremrangebyscore: Internal functions
Function, zrevrange: Internal functions
Function, zrevrangebylex: Internal functions
Function, zrevrangebyscore: Internal functions
Function, zrevrank: Internal functions
Function, zscan: Internal functions
Function, zscore: Internal functions
Function, zunionstore: Internal functions

G
Generic Function, (setf conn-socket): Internal generic functions
Generic Function, (setf conn-stream): Internal generic functions
Generic Function, conn-auth: Internal generic functions
Generic Function, conn-host: Internal generic functions
Generic Function, conn-port: Internal generic functions
Generic Function, conn-socket: Internal generic functions
Generic Function, conn-stream: Internal generic functions
Generic Function, expect: Exported generic functions
Generic Function, redis-error-error: Internal generic functions
Generic Function, redis-error-message: Exported generic functions
Generic Function, tell: Exported generic functions
get: Internal functions
getbit: Internal functions
getrange: Internal functions
getset: Internal functions

H
hdel: Internal functions
hexists: Internal functions
hget: Internal functions
hgetall: Internal functions
hincrby: Internal functions
hincrbyfloat: Internal functions
hkeys: Internal functions
hlen: Internal functions
hmget: Internal functions
hmset: Internal functions
hscan: Internal functions
hset: Internal functions
hsetnx: Internal functions
hvals: Internal functions

I
incr: Internal functions
incrby: Internal functions
incrbyfloat: Internal functions
info: Internal functions

K
keys: Internal functions

L
lastsave: Internal functions
lindex: Internal functions
linsert: Internal functions
llen: Internal functions
lpop: Internal functions
lpush: Internal functions
lpushx: Internal functions
lrange: Internal functions
lrem: Internal functions
lset: Internal functions
ltrim: Internal functions

M
Macro, def-cmd: Exported macros
Macro, def-expect-method: Exported macros
Macro, read-bulk-reply: Internal macros
Macro, reconnect-restart-case: Internal macros
Macro, with-connection: Exported macros
Macro, with-persistent-connection: Exported macros
Macro, with-pipelining: Exported macros
Macro, with-reconnect-restart: Internal macros
Macro, with-recursive-connection: Exported macros
Macro, with-redis-in: Internal macros
Method, (setf conn-socket): Internal generic functions
Method, (setf conn-stream): Internal generic functions
Method, conn-auth: Internal generic functions
Method, conn-host: Internal generic functions
Method, conn-port: Internal generic functions
Method, conn-socket: Internal generic functions
Method, conn-stream: Internal generic functions
Method, expect: Exported generic functions
Method, expect: Exported generic functions
Method, expect: Exported generic functions
Method, expect: Exported generic functions
Method, expect: Exported generic functions
Method, expect: Exported generic functions
Method, expect: Exported generic functions
Method, expect: Exported generic functions
Method, expect: Exported generic functions
Method, expect: Exported generic functions
Method, expect: Exported generic functions
Method, expect: Exported generic functions
Method, expect: Exported generic functions
Method, expect: Exported generic functions
Method, redis-error-error: Internal generic functions
Method, redis-error-message: Exported generic functions
Method, tell: Exported generic functions
Method, tell: Exported generic functions
Method, tell: Exported generic functions
Method, tell: Exported generic functions
Method, tell: Exported generic functions
Method, tell: Exported generic functions
Method, tell: Exported generic functions
Method, tell: Exported generic functions
Method, tell: Exported generic functions
Method, tell: Exported generic functions
Method, tell: Exported generic functions
Method, tell: Exported generic functions
Method, tell: Exported generic functions
Method, tell: Exported generic functions
Method, tell: Exported generic functions
Method, tell: Exported generic functions
Method, tell: Exported generic functions
mget: Internal functions
migrate: Internal functions
move: Internal functions
mset: Internal functions
msetnx: Internal functions
multi: Internal functions

O
object-encoding: Internal functions
object-idletime: Internal functions
object-refcount: Internal functions
open-connection: Exported functions

P
parse-float: Internal functions
persist: Internal functions
pexpire: Internal functions
pexpireat: Internal functions
pfadd: Internal functions
pfcount: Internal functions
pfmerge: Internal functions
ping: Internal functions
psubscribe: Internal functions
pttl: Internal functions
publish: Internal functions
punsubscribe: Internal functions

Q
quit: Internal functions

R
radix-values: Internal functions
randomkey: Internal functions
read-bulk-reply: Internal macros
reconnect: Exported functions
reconnect-restart-case: Internal macros
red-append: Exported functions
red-auth: Exported functions
red-bgrewriteaof: Exported functions
red-bgsave: Exported functions
red-bitcount: Exported functions
red-bitop: Exported functions
red-bitpos: Exported functions
red-blpop: Exported functions
red-brpop: Exported functions
red-brpoplpush: Exported functions
red-client-getname: Exported functions
red-client-pause: Exported functions
red-client-setname: Exported functions
red-cluster-slots: Exported functions
red-command: Exported functions
red-command-count: Exported functions
red-command-getkeys: Exported functions
red-command-info: Exported functions
red-config-get: Exported functions
red-config-resetstat: Exported functions
red-config-rewrite: Exported functions
red-config-set: Exported functions
red-dbsize: Exported functions
red-decr: Exported functions
red-decrby: Exported functions
red-del: Exported functions
red-discard: Exported functions
red-dump: Exported functions
red-echo: Exported functions
red-eval: Exported functions
red-evalsha: Exported functions
red-exec: Exported functions
red-exists: Exported functions
red-expire: Exported functions
red-expireat: Exported functions
red-flushall: Exported functions
red-flushdb: Exported functions
red-get: Exported functions
red-getbit: Exported functions
red-getrange: Exported functions
red-getset: Exported functions
red-hdel: Exported functions
red-hexists: Exported functions
red-hget: Exported functions
red-hgetall: Exported functions
red-hincrby: Exported functions
red-hincrbyfloat: Exported functions
red-hkeys: Exported functions
red-hlen: Exported functions
red-hmget: Exported functions
red-hmset: Exported functions
red-hscan: Exported functions
red-hset: Exported functions
red-hsetnx: Exported functions
red-hvals: Exported functions
red-incr: Exported functions
red-incrby: Exported functions
red-incrbyfloat: Exported functions
red-info: Exported functions
red-keys: Exported functions
red-lastsave: Exported functions
red-lindex: Exported functions
red-linsert: Exported functions
red-llen: Exported functions
red-lpop: Exported functions
red-lpush: Exported functions
red-lpushx: Exported functions
red-lrange: Exported functions
red-lrem: Exported functions
red-lset: Exported functions
red-ltrim: Exported functions
red-mget: Exported functions
red-migrate: Exported functions
red-move: Exported functions
red-mset: Exported functions
red-msetnx: Exported functions
red-multi: Exported functions
red-object-encoding: Exported functions
red-object-idletime: Exported functions
red-object-refcount: Exported functions
red-persist: Exported functions
red-pexpire: Exported functions
red-pexpireat: Exported functions
red-pfadd: Exported functions
red-pfcount: Exported functions
red-pfmerge: Exported functions
red-ping: Exported functions
red-psubscribe: Exported functions
red-pttl: Exported functions
red-publish: Exported functions
red-punsubscribe: Exported functions
red-quit: Exported functions
red-randomkey: Exported functions
red-rename: Exported functions
red-renamenx: Exported functions
red-restore: Exported functions
red-role: Exported functions
red-rpop: Exported functions
red-rpoplpush: Exported functions
red-rpush: Exported functions
red-rpushx: Exported functions
red-sadd: Exported functions
red-save: Exported functions
red-scan: Exported functions
red-scard: Exported functions
red-script-exists: Exported functions
red-script-flush: Exported functions
red-script-kill: Exported functions
red-script-load: Exported functions
red-sdiff: Exported functions
red-sdiffstore: Exported functions
red-select: Exported functions
red-set: Exported functions
red-setbit: Exported functions
red-setex: Exported functions
red-setnx: Exported functions
red-setrange: Exported functions
red-shutdown: Exported functions
red-sinter: Exported functions
red-sinterstore: Exported functions
red-sismember: Exported functions
red-slaveof: Exported functions
red-slowlog: Exported functions
red-smembers: Exported functions
red-smove: Exported functions
red-sort: Exported functions
red-spop: Exported functions
red-srandmember: Exported functions
red-srem: Exported functions
red-sscan: Exported functions
red-strlen: Exported functions
red-subscribe: Exported functions
red-substr: Exported functions
red-sunion: Exported functions
red-sunionstore: Exported functions
red-sync: Exported functions
red-time: Exported functions
red-ttl: Exported functions
red-type: Exported functions
red-unsubscribe: Exported functions
red-unwatch: Exported functions
red-watch: Exported functions
red-zadd: Exported functions
red-zcard: Exported functions
red-zcount: Exported functions
red-zincrby: Exported functions
red-zinterstore: Exported functions
red-zlexcount: Exported functions
red-zrange: Exported functions
red-zrangebyscore: Exported functions
red-zrank: Exported functions
red-zrem: Exported functions
red-zremrangebylex: Exported functions
red-zremrangebyrank: Exported functions
red-zremrangebyscore: Exported functions
red-zrevrange: Exported functions
red-zrevrangebylex: Exported functions
red-zrevrangebyscore: Exported functions
red-zrevrank: Exported functions
red-zscan: Exported functions
red-zscore: Exported functions
red-zunionstore: Exported functions
redis-error-error: Internal generic functions
redis-error-error: Internal generic functions
redis-error-message: Exported generic functions
redis-error-message: Exported generic functions
rename: Internal functions
renamenx: Internal functions
reopen-connection: Internal functions
restore: Internal functions
role: Internal functions
rpop: Internal functions
rpoplpush: Internal functions
rpush: Internal functions
rpushx: Internal functions

S
sadd: Internal functions
save: Internal functions
scan: Internal functions
scard: Internal functions
script-exists: Internal functions
script-flush: Internal functions
script-kill: Internal functions
script-load: Internal functions
sdiff: Internal functions
sdiffstore: Internal functions
select: Internal functions
set: Internal functions
setbit: Internal functions
setex: Internal functions
setnx: Internal functions
setrange: Internal functions
shutdown: Internal functions
sinter: Internal functions
sinterstore: Internal functions
sismember: Internal functions
slaveof: Internal functions
slowlog: Internal functions
smembers: Internal functions
smove: Internal functions
sort: Internal functions
spop: Internal functions
srandmember: Internal functions
srem: Internal functions
sscan: Internal functions
strlen: Internal functions
subscribe: Internal functions
substr: Internal functions
sunion: Internal functions
sunionstore: Internal functions
sync: Internal functions

T
tell: Exported generic functions
tell: Exported generic functions
tell: Exported generic functions
tell: Exported generic functions
tell: Exported generic functions
tell: Exported generic functions
tell: Exported generic functions
tell: Exported generic functions
tell: Exported generic functions
tell: Exported generic functions
tell: Exported generic functions
tell: Exported generic functions
tell: Exported generic functions
tell: Exported generic functions
tell: Exported generic functions
tell: Exported generic functions
tell: Exported generic functions
tell: Exported generic functions
time: Internal functions
ttl: Internal functions
type: Internal functions

U
unsubscribe: Internal functions
unwatch: Internal functions

W
watch: Internal functions
with-connection: Exported macros
with-persistent-connection: Exported macros
with-pipelining: Exported macros
with-reconnect-restart: Internal macros
with-recursive-connection: Exported macros
with-redis-in: Internal macros

Z
zadd: Internal functions
zcard: Internal functions
zcount: Internal functions
zincrby: Internal functions
zinterstore: Internal functions
zlexcount: Internal functions
zrange: Internal functions
zrangebyscore: Internal functions
zrank: Internal functions
zrem: Internal functions
zremrangebylex: Internal functions
zremrangebyrank: Internal functions
zremrangebyscore: Internal functions
zrevrange: Internal functions
zrevrangebylex: Internal functions
zrevrangebyscore: Internal functions
zrevrank: Internal functions
zscan: Internal functions
zscore: Internal functions
zunionstore: Internal functions

Jump to:   (  
A   B   C   D   E   F   G   H   I   K   L   M   O   P   Q   R   S   T   U   W   Z  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *   +  
A   E   H   M   P   S  
Index Entry  Section

*
*cmd-prefix*: Exported special variables
*connection*: Exported special variables
*echo-p*: Exported special variables
*echo-stream*: Exported special variables
*pipeline*: Internal special variables
*pipelined*: Internal special variables

+
+utf8+: Internal special variables

A
auth: Exported classes

E
error: Exported conditions

H
host: Exported classes

M
message: Exported conditions

P
port: Exported classes

S
Slot, auth: Exported classes
Slot, error: Exported conditions
Slot, host: Exported classes
Slot, message: Exported conditions
Slot, port: Exported classes
Slot, socket: Exported classes
Slot, stream: Exported classes
socket: Exported classes
Special Variable, *cmd-prefix*: Exported special variables
Special Variable, *connection*: Exported special variables
Special Variable, *echo-p*: Exported special variables
Special Variable, *echo-stream*: Exported special variables
Special Variable, *pipeline*: Internal special variables
Special Variable, *pipelined*: Internal special variables
Special Variable, +utf8+: Internal special variables
stream: Exported classes

Jump to:   *   +  
A   E   H   M   P   S  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   C   P   R   S  
Index Entry  Section

C
cl-redis: The cl-redis system
Class, redis-connection: Exported classes
Condition, redis-bad-reply: Exported conditions
Condition, redis-connection-error: Exported conditions
Condition, redis-error: Exported conditions
Condition, redis-error-reply: Exported conditions

P
Package, red: The red package
Package, redis: The redis package

R
red: The red package
redis: The redis package
redis-bad-reply: Exported conditions
redis-connection: Exported classes
redis-connection-error: Exported conditions
redis-error: Exported conditions
redis-error-reply: Exported conditions

S
System, cl-redis: The cl-redis system

Jump to:   C   P   R   S