Redis

The value to be compressed

The compressed result

The compressed value to uncompress.

The uncompressed result.

The key/string to prefix

The prefixed string

The value to serialize

The serialized result

The value to unserialize

The unserialized result

The value to pack

The packed result having been serialized and compressed.

The value which has been serialized and compressed.

The uncompressed and eserialized value.

The key in question

The data to append to the key.

The new string length of the key or false on failure.

$redis->set('foo', 'hello);

$redis->append('foo', 'world');

A string password, or an array with one or two string elements.

Whether the AUTH was successful.

Whether the command was successful.

Whether the command was successful.

The key in question (must be a string key)

The index where Redis should start counting. If omitted it defaults to zero, which means the start of the string.

The index where Redis should stop counting. If omitted it defaults to -1, meaning the very end of the string.

Whether or not Redis should treat $start and $end as bit positions, rather than bytes.

The number of bits set in the requested range.

The key to check (must be a string)

Whether to look for an unset (0) or set (1) bit.

Where in the string to start looking.

Where in the string to stop looking.

If true, Redis will treat $start and $end as BIT values and not bytes, so if start was 0 and end was 2, Redis would only search the first two bits.

The position of the first set or unset bit.

This can either be a string key or an array of one or more keys.

If the previous argument was a string key, this can either be an additional key, or the timeout you wish to send to the command.

Can return various things depending on command and data in Redis.

$redis->blPop('list1', 'list2', 'list3', 1.5);

$relay->blPop(['list1', 'list2', 'list3'], 1.5);

The source list

The destination list

The number of seconds to wait. Note that you must be connected to Redis >= 6.0.0 to send a floating point timeout.

If the previous argument was an array, this argument must be a timeout value. Otherwise it could also be another key.

Can consist of additional keys, until the last argument which needs to be a timeout.

The popped elements.

$redis->bzPopMax('key1', 'key2', 'key3', 1.5);

$redis->bzPopMax(['key1', 'key2', 'key3'], 1.5);

How long to block if there are no element available

The sorted sets to pop from

The string 'MIN' or 'MAX' (case insensitive) telling Redis whether you wish to pop the lowest or highest scoring members from the set(s).

Pop up to how many elements.

This function will return an array of popped elements, or false depending on whether any elements could be popped within the specified timeout.

NOTE: If Redis::OPT_NULL_MULTIBULK_AS_NULL is set to true via Redis::setOption(), this method will instead return NULL when Redis doesn't pop any elements.

One or more sorted sets

The string 'MIN' or 'MAX' (case insensitive) telling Redis whether you want to pop the lowest or highest scoring elements.

Pop up to how many elements at once.

An array of popped elements or false if none could be popped.

The number of seconds Redis will block when no elements are available.

One or more Redis LISTs to pop from.

The string 'LEFT' or 'RIGHT' (case insensitive), telling Redis whether to pop elements from the beginning or end of the LISTs.

Pop up to how many elements at once.

One or more elements popped from the list(s) or false if all LISTs were empty.

An array with one or more Redis LIST key names.

The string 'LEFT' or 'RIGHT' (case insensitive), telling Redis whether to pop\ elements from the beginning or end of the LISTs.

The maximum number of elements to pop at once.

One or more elements popped from the LIST(s) or false if all the LISTs were empty.

This should always return true or throw an exception if we're not connected.

$redis = new Redis(['host' => 'localhost']);

$redis->set('string', 'this_is_a_string');

$redis->smembers('string');

var_dump($redis->getLastError());

$redis->clearLastError();

var_dump($redis->getLastError());

The CONFIG operation to execute (e.g. GET, SET, REWRITE).

One or more keys or values.

The value if this is a CONFIG SET operation.

$redis->config('GET', 'timeout');

$redis->config('GET', ['timeout', 'databases']);

$redis->config('SET', 'timeout', 30);

$redis->config('SET', ['timeout' => 30, 'loglevel' => 'warning']);

The key to copy

The name of the new key created from the source key.

An array with modifiers on how COPY should operate.

$options = [
    'REPLACE' => true|false # Whether to replace an existing key.
    'DB' => int             # Copy key to specific db.
];

True if the copy was completed and false if not.

$redis->pipeline()

      ->select(1)

      ->del('newkey')

      ->select(0)

      ->del('newkey')

      ->mset(['source1' => 'value1', 'exists' => 'old_value'])

      ->exec();



var_dump($redis->copy('source1', 'newkey'));

var_dump($redis->copy('source1', 'newkey', ['db' => 1]));

var_dump($redis->copy('source1', 'exists'));

var_dump($redis->copy('source1', 'exists', ['REPLACE' => true]));

The number of keys or false on failure.

$redis = new Redis(['host' => 'localhost']);

$redis->flushdb();

$redis->set('foo', 'bar');

var_dump($redis->dbsize());

$redis->mset(['a' => 'a', 'b' => 'b', 'c' => 'c', 'd' => 'd']);

var_dump($redis->dbsize());

The key to decrement

How much to decrement the key. Note that if this value is not sent or is set to 1, PhpRedis will actually invoke the 'DECR' command. If it is any value other than 1 PhpRedis will actually send the DECRBY command.

The new value of the key or false on failure.

$redis->decr('counter');

$redis->decr('counter', 2);

The integer key to decrement.

How much to decrement the key.

The new value of the key or false on failure.

$redis->decrby('counter', 1);

$redis->decrby('counter', 2);

One or more additional keys passed in a variadic fashion.

The number of keys that were deleted

$redis->del('key:0', 'key:1');

$redis->del(['key:2', 'key:3', 'key:4']);

True if we could discard the transaction.

$redis->getMode();

$redis->set('foo', 'bar');

$redis->discard();

$redis->getMode();

The key to dump.

A binary string representing the key's value.

$redis->zadd('zset', 0, 'zero', 1, 'one', 2, 'two');

$binary = $redis->dump('zset');

$redis->restore('new-zset', 0, $binary);

The string to echo

The string sent to Redis or false on failure.

$redis->echo('Hello, World');

A string containing the LUA script

An array of arguments to pass to this script

How many of the arguments are keys. This is needed as redis distinguishes between key name arguments and other data.

LUA scripts may return arbitrary data so this method can return strings, arrays, nested arrays, etc.

Arguments to send to the script.

The number of arguments that are keys

Returns whatever the specific script does.

The array of pipeline'd or multi replies or false on failure.

$res = $redis->multi()

->set('foo', 'bar')

->get('foo')

->del('list')

->rpush('list', 'one', 'two', 'three')

->exec();

Either an array of keys or a string key

If the previous argument was a string, you may send any number of additional keys to test.

The number of keys that do exist and false on failure

$redis->exists(['k1', 'k2', 'k3']);

$redis->exists('k4', 'k5', 'notakey');

The key to set an expiration on.

A two character modifier that changes how the command works.

NX - Set expiry only if key has no expiry
XX - Set expiry only if key has an expiry
LT - Set expiry only when new expiry is < current expiry
GT - Set expiry only when new expiry is > current expiry

True if an expiration was set and false otherwise.

The key to set an expiration on.

The unix timestamp to expire at.

An option 'mode' that modifies how the command acts (see Redis::expire).

True if an expiration was set, false if not.

The key to check.

The timestamp when the key expires, or -1 if the key has no expiry and -2 if the key doesn't exist.

$redis->setEx('mykey', 60, 'myval');

$redis->expiretime('mykey');

The key to check

The expiration timestamp of this key (in milliseconds) or -1 if the key has no expiration, and -2 if it does not exist.

Whether to perform the task in a blocking or non-blocking way.

Whether to perform the task in a blocking or non-blocking way.

The sorted set to add data to.

The longitude of the first member

The latitude of the first member.

You can continue to pass longitude, latitude, and member arguments to add as many members as you wish. Optionally, the final argument may be a string with options for the command Redis documentation for the options.

The number of added elements is returned. If the 'CH' option is specified, the return value is the number of members changed.

$redis->geoAdd('cities', -121.8374, 39.7284, 'Chico', -122.03218, 37.322, 'Cupertino');

$redis->geoadd('cities', -121.837478, 39.728494, 'Chico', ['XX', 'CH']);

The Sorted set to query.

The first member.

The second member.

Which unit to use when computing distance, defaulting to meters.

M  - meters
KM - kilometers
FT - feet
MI - miles

The calculated distance in whichever units were specified or false if one or both members did not exist.

$redis->geodist('cities', 'Chico', 'Cupertino', 'mi');

The key to query

The first member to request

One or more additional members to request.

An array of GeoHash encoded values.

$redis->geohash('cities', 'Chico', 'Cupertino');

The set to query.

The first member to query.

One or more members to query.

array of longitude and latitude pairs.

$redis->geopos('cities', 'Seattle', 'New York');

The set to query

The longitude of the location to query.

The latitude of the location to query.

The radius of the area to include.

The unit of the provided radius (defaults to 'meters). See Redis::geodist for possible units.

An array of options that modifies how the command behaves.

$options = [
    'WITHCOORD',     # Return members and their coordinates.
    'WITHDIST',      # Return members and their distances from the center.
    'WITHHASH',      # Return members GeoHash string.
    'ASC' | 'DESC',  # The sort order of returned members

    # Limit to N returned members.  Optionally a two element array may be
    # passed as the `LIMIT` argument, and the `ANY` argument.
    'COUNT' => [<int>], or [<int>, <bool>]

    # Instead of returning members, store them in the specified key.
    'STORE' => <string>

    # Store the distances in the specified key
    'STOREDIST' => <string>
];

This command can return various things, depending on the options passed.

$redis->georadius('cities', 47.608013, -122.335167, 1000, 'km');

The key to query.

The member to treat as the center of the query.

The radius from the member to include.

The unit of the provided radius See Redis::geodist for possible units.

An array with various options to modify the command's behavior. See Redis::georadius for options.

This command can return various things depending on options.

$redis->georadiusbymember('cities', 'Seattle', 200, 'mi');

The set to query.

Either a two element array with longitude and latitude, or a string representing a member of the set.

Either a number representine the radius of a circle to search, or a two element array representing the width and height of a box to search.

The unit of our shape. See Redis::geodist for possible units.

Redis::georadius for options. Note that the STORE options are not allowed for this command.

The destination where results will be stored.

The key to query.

Either a two element array with longitude and latitude, or a string representing a member of the set.

Either a number representine the radius of a circle to search, or a two element array representing the width and height of a box to search.

The unit of our shape. See Redis::geodist for possible units.

$options = [
    'ASC' | 'DESC',  # The sort order of returned members
    'WITHDIST'       # Also store distances.

    # Limit to N returned members.  Optionally a two element array may be
    # passed as the `LIMIT` argument, and the `ANY` argument.
    'COUNT' => [<int>], or [<int>, <bool>]
];

The key to query

The keys value or false if it did not exist.

$redis->get('foo');

The authentication information used to authenticate the connection.

The key to query.

The Nth bit that we want to query.

$redis->getbit('bitmap', 1337);

The key to query

Options to modify how the command works.

$options = [
    'EX'     => <seconds>      # Expire in N seconds
    'PX'     => <milliseconds> # Expire in N milliseconds
    'EXAT'   => <timestamp>    # Expire at a unix timestamp (in seconds)
    'PXAT'   => <mstimestamp>  # Expire at a unix timestamp (in milliseconds);
    'PERSIST'                  # Remove any configured expiration on the key.
];

The key's value or false if it didn't exist.

$redis->getEx('mykey', ['EX' => 60]);

database we're connected to.

The key to get/delete.

The value of the key or false if it didn't exist.

$redis->getdel('token:123');

The host or Unix socket.

The error string or NULL if there is none.

The mode we're in.

The setting itself or false on failure

The ID or NULL if we don't have one.

The port.

The string to query.

The zero-based starting index.

The zero-based ending index.

The substring or false on failure.

$redis->set('silly-word', 'Supercalifragilisticexpialidocious');

echo $redis->getRange('silly-word', 0, 4) . "\n";

The first key to check

The second key to check

An optional array of modifiers for the command.

$options = [
    'MINMATCHLEN'  => int  # Exclude matching substrings that are less than this value

    'WITHMATCHLEN' => bool # Whether each match should also include its length.

    'LEN'                  # Return the length of the longest subsequence

    'IDX'                  # Each returned match will include the indexes where the
                           # match occurs in each string.
];

NOTE: 'LEN' cannot be used with 'IDX'.

Various reply types depending on options.

$redis->set('seq1', 'gtaggcccgcacggtctttaatgtatccctgtttaccatgccatacctgagcgcatacgc');

$redis->set('seq2', 'aactcggcgcgagtaccaggccaaggtcgttccagagcaaagactcgtgccccgctgagc');

echo $redis->lcs('seq1', 'seq2') . "\n";

The timeout.

The key to set.

The value to set the key to.

The old value of the key or false if it didn't exist.

$redis->getset('captain', 'Pike');

$redis->getset('captain', 'Kirk');

The currently set timeout or false on failure (e.g. we aren't connected).

The hash key in question.

The first field to remove

One or more additional fields to remove.

The number of fields actually removed.

$redis->hDel('communication', 'Alice', 'Bob');

The hash to query.

The field to check

True if it exists, false if not.

$redis->hExists('communication', 'Alice');

The hash to query.

All fields and values or false if the key didn't exist.

$redis->hgetall('myhash');

The hash to modify

The field to increment

How much to increment the value.

The new value of the field.

$redis->hMSet('player:1', ['name' => 'Alice', 'score' => 0]);

$redis->hincrby('player:1', 'score', 10);

The hash with the field to increment.

The field to increment.

The field value after incremented.

$redis->hincrbyfloat('numbers', 'tau', 2 * 3.1415926);

The hash to query.

The fields in the hash or false if the hash doesn't exist.

$redis->hkeys('myhash');

The hash to check.

The number of fields or false if the key didn't exist.

$redis->hlen('myhash');

The hash to query.

One or more fields to query in the hash.

The fields and values or false if the key didn't exist.

$redis->hMGet('player:1', ['name', 'score']);

The hash to create/update

An associative array with fields and their values.

True if the operation was successful

$redis->hmset('updates', ['status' => 'starting', 'elapsed' => 0]);

The hash to query.

An array of options to modify how the command behaves.

$options = [
    'COUNT'      => int  # An optional number of fields to return.
    'WITHVALUES' => bool # Also return the field values.
];

One or more random fields (and possibly values).

$redis->hrandfield('settings');

$redis->hrandfield('settings', ['count' => 2, 'withvalues' => true]);

The hash to update.

The value to set.

True if the field was set and false if not.

$redis->hsetnx('player:1', 'lock', 'enabled');

$redis->hsetnx('player:1', 'lock', 'enabled');

The hash to query.

The field to query.

The string length of the field or false.

$redis = new Redis(['host' => 'localhost']);

$redis->del('hash');

$redis->hmset('hash', ['50bytes' => str_repeat('a', 50)]);

$redis->hstrlen('hash', '50bytes');

The hash to query.

The values from the hash.

$redis->hvals('player:1');

The hash to query.

The scan iterator, which should be initialized to NULL before the first call. This value will be updated after every call to hscan, until it reaches zero meaning the scan is complete.

An optional glob-style pattern to filter fields with.

An optional hint to Redis about how many fields and values to return per HSCAN.

An array with a subset of fields and values.

$redis = new Redis(['host' => 'localhost']);



$redis->del('big-hash');



for ($i = 0; $i < 1000; $i++) {

    $fields["field:$i"] = "value:$i";

}



$redis->hmset('big-hash', $fields);



$it = NULL;



do {

    // Scan the hash but limit it to fields that match '*:1?3'

    $fields = $redis->hscan('big-hash', $it, '*:1?3');



    foreach ($fields as $field => $value) {

        echo "[$field] => $value\n";

    }

} while ($it != 0);

The key to increment

An optional amount to increment by.

The new value of the key after incremented.

$redis->incr('mycounter');

$redis->incr('mycounter', 10);

The key to increment.

The amount to increment.

$redis->set('primes', 2);

$redis->incrby('primes', 1);

$redis->incrby('primes', 2);

$redis->incrby('primes', 2);

$redis->incrby('primes', 4);

The key to increment

How much to increment (or decrement) the value.

The new value of the key or false if the key didn't contain a string.

$redis->incrbyfloat('tau', 3.1415926);

$redis->incrbyfloat('tau', 3.1415926);

Optional section(s) you wish Redis server to return.

True if we are, false if not

The list

The number of elements in the list or false on failure.

The source list.

The destination list

Where in the source list to retrieve the element. This can be either Redis::LEFT, or Redis::RIGHT.

Where in the destination list to put the element. This can be either Redis::LEFT, or Redis::RIGHT.

The element removed from the source list.

$redis->rPush('numbers', 'one', 'two', 'three');

$redis->lMove('numbers', 'odds', Redis::LEFT, Redis::LEFT);

The list to pop from.

Optional number of elements to remove. By default one element is popped.

Will return the element(s) popped from the list or false/NULL if none was removed.

$redis->lpop('mylist');

$redis->lpop('mylist', 4);

The list to query.

The value to search for.

Options to configure how the command operates

$options = [
    # How many matches to return.  By default a single match is returned.
    # If count is set to zero, it means unlimited.
    'COUNT' => <num-matches>

    # Specify which match you want returned.  `RANK` 1 means "the first match"
    # 2 means the second, and so on.  If passed as a negative number the
    # RANK is computed right to left, so a `RANK` of -1 means "the last match".
    'RANK'  => <rank>

    # This argument allows you to limit how many elements Redis will search before
    # returning.  This is useful to prevent Redis searching very long lists while
    # blocking the client.
    'MAXLEN => <max-len>
];

Returns one or more of the matching indexes, or null/false if none were found.

The list to prepend.

One or more elements to prepend.

The new length of the list after prepending.

$redis->lPush('mylist', 'cat', 'bear', 'aligator');

The list to append to.

one or more elements to append.

The new length of the list

$redis->rPush('mylist', 'xray', 'yankee', 'zebra');

The key to prepend to.

The value to prepend.

The new length of the list.

The key to prepend to.

The value to prepend.

The new length of the list.

The list to modify.

The position of the element to change.

The new value.

True if the list was modified.

The unix timestamp of the last save time

The key to query

The index to check.

The index or NULL/false if the element was not found.

The list to query.

The beginning index to retrieve. This number can be negative meaning start from the end of the list.

The end index to retrieve. This can also be negative to start from the end of the list.

The range of elements between the indexes.

$redis->lrange('mylist', 0, -1);  // the whole list

$redis->lrange('mylist', -2, -1); // the last two elements in the list.

The list to truncate.

The value to remove.

How many elements matching the value to remove.

The number of elements removed.

The list to trim

The starting index to keep

The ending index to keep.

true if the list was trimmed.

$redis->ltrim('mylist', 0, 3);  // Keep the first four elements

The keys to retrieve

an array of keys with their values.

$redis->mget(['key1', 'key2']);

The key to move

True if the key was moved

An array with keys and their values.

True if the keys could be set.

$redis->mSet(['foo' => 'bar', 'baz' => 'bop']);

An array of keys with their values.

True if the keys were set and false if not.

$redis->msetnx(['foo' => 'bar', 'baz' => 'bop']);

The type of transaction to start. This can either be Redis::MULTI or `Redis::PIPELINE'.

True if the transaction could be started.

$redis->multi();

$redis->set('foo', 'bar');

$redis->get('foo');

$redis->exec();

The key to operate against.

True if a timeout was removed and false if it was not or the key didn't exist.

The key to set an expiration on. @param string $mode A two character modifier that changes how the command works.

@return Redis|bool True if an expiry was set on the key, and false otherwise.

The key in question.

One or more elements to add.

Returns 1 if the set was altered, and zero if not.

The key name we wish to query.

The estimated cardinality of the set.

The destination key.

One or more source keys.

Always returns true.

An optional string message that Redis will reply with, if passed.

If passed no message, this command will simply return true. If a message is passed, it will return the message.

$redis->ping();

$redis->ping('beep boop');

The redis object is returned, to facilitate method chaining.

$redis->pipeline()

->set('foo', 'bar')

->del('mylist')

->rpush('mylist', 'a', 'b', 'c')

->exec();

The key to set

The TTL to set, in milliseconds.

The value to set the key to.

True if the key could be set.

$redis->psetex('mykey', 1000, 'myval');

One or more patterns to subscribe to.

A callback with the following prototype:

function ($redis, $channel, $message) { }

True if we were subscribed.

The key to check.

The key's TTL or one of two special values if it has none.

-1 - The key has no TTL.
-2 - The key did not exist.

$redis->pttl('ttl-key');

The channel to publish to.

The message itself.

The number of subscribed clients to the given channel.

One or more glob-style patterns of channel names.

The array of subscribed patterns or false on failure.

A redis LIST key name.

The maximum number of elements to pop at once. NOTE: The count argument requires Redis >= 6.2.0

One ore more popped elements or false if all were empty.

$redis->rPop('mylist');

$redis->rPop('mylist', 4);

A random key name or false if no keys exist

The command to execute

One or more arguments to pass to the command.

Can return any number of things depending on command executed.

$redis->rawCommand('del', 'mystring', 'mylist');

$redis->rawCommand('set', 'mystring', 'myvalue');

$redis->rawCommand('rpush', 'mylist', 'one', 'two', 'three');

The original name of the key

The new name for the key

True if the key was renamed or false if not.

The source key name

The destination key name.

True if the key was renamed, false if not.

$redis->set('src', 'src_key');

$redis->set('existing-dst', 'i_exist');



$redis->renamenx('src', 'dst');

$redis->renamenx('dst', 'existing-dst');

Should always return true unless there is an error.

The name of the key you wish to create.

What Redis should set the key's TTL (in milliseconds) to once it is created. Zero means no TTL at all.

The serialized binary value of the string (generated by DUMP).