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.

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.

The integer key to decrement.

How much to decrement the key.

The new value of the key or false on failure.

One or more additional keys passed in a variadic fashion.

The number of keys that were deleted

True if we could discard the transaction.

The key to dump.

A binary string representing the key's value.

The string to echo

The string sent to Redis or false on failure.

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.

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

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.

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 authentication information used to authenticate the connection.

database we're connected to.

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.

The first key to check

The second key to check

An optional array of modifiers for the comand.

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

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.

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.

The hash to query.

The field to check

True if it exists, false if not.

The hash to query.

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

The hash to modify

The field to increment

How much to increment the value.

The new value of the field.

The hash with the field to increment.

The field to increment.

The field value after incremented.

The hash to query.

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

The hash to check.

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

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.

The hash to create/update

An associative array with fields and their values.

True if the operation was successful

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

The hash to update.

The value to set.

True if the field was set and false if not.

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.

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

$redis->del('player');

$redis->hmset('player', ['name' => 'Alice', 'score' => 1337]);

// array(2) {
//   ["name"]=>
//   string(5) "Alice"
//   ["score"]=>
//   string(4) "1337"
// }
$redis->hgetall('player');
?>

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.

<?php
$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);

// --- OUTPUT ---
// [field:143] => value:143
// [field:133] => value:133
// [field:163] => value:163
// [field:183] => value:183
// [field:153] => value:153
// [field:113] => value:113
// [field:103] => value:103
// [field:193] => value:193
// [field:123] => value:123
// [field:173] => value:173
?>

The key to increment

An optional amount to increment by.

The new value of the key after incremented.

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

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

// int(2);
$redis->incr('counter');

// int(4);
$redis->incr('counter', 2);
?>

The key to increment.

The amount to increment.

<?php

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

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

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

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

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

// int(11)
$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.

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

$redis->del('tau');

// float(3.1415926)
var_dump($redis->incrByFloat('tau', 3.1415926));

// float(6.2831852)
var_dump($redis->incrByFloat('tau', 3.1415926));
?>

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

True if we are, false if not

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.

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

// bool(true)
$redis->ping();

// string(9) "beep boop"
$redis->ping('beep boop');
?>

The redis object is returned, to facilitate method chaining.

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

// array(3) {
//   [0]=>
//   bool(true)
//   [1]=>
//   int(0)
//   [2]=>
//   int(3)
// }
$redis->pipeline()
      ->set('foo', 'bar')
      ->del('mylist')
      ->rpush('mylist', 'a', 'b', 'c')
      ->exec();
?>

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 keys TTL or false on failure.

NOTE: -1 means a key has no TTL and -2 means the key doesn't exist.

<?php

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

$redis->setex('ttl-key', 60, 'ttl-value');

// int(60000)
var_dump($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.

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

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

// string(5) "three"
$redis->rPop('mylist');

// string(3) "two"
$redis->rPop('mylist');

// string(3) "one"
$redis->rPop('mylist');
?>

A random key name or false if no keys exist

The command to execute

One or more arguments to pass to the command.

<?php

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

$redis->rawCommand('del', 'mystring', 'mylist');
$redis->rawCommand('set', 'mystring', 'myvalue');
$redis->rawCommand('rpush', 'mylist', 'one', 'two', 'three');

// string(7) "myvalue"
$redis->rawCommand('get', 'mystring');

// array(3) {
//   [0]=>
//   string(3) "one"
//   [1]=>
//   string(3) "two"
//   [2]=>
//   string(5) "three"
// }
$redis->rawCommand('lrange', 'mylist', 0, -1);
?>

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.

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

$redis->del('src', 'dst', 'existing-dst');

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

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

// bool(false)
$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).

An array of additional options that modifies how the command operates.

$options = [
    'ABSTTL'          // If this is present, the `$ttl` provided by the user should
                      // be an absolute timestamp, in milliseconds()

    'REPLACE'         // This flag instructs Redis to store the key even if a key with
                      // that name already exists.

    'IDLETIME' => int // Tells Redis to set the keys internal 'idletime' value to a
                      // specific number (see the Redis command OBJECT for more info).
    'FREQ'     => int // Tells Redis to set the keys internal 'FREQ' value to a specific
                      // number (this relates to Redis' LFU eviction algorithm).
];

True if the key was stored, false if not.

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

$redis->del('captains');

$redis->sAdd('captains', 'Janeway', 'Picard', 'Sisko', 'Kirk', 'Archer');

$serialized = $redis->dump('captains');

$redis->select(1);
$redis->restore('captains-backup', 0, $serialized);

//array(5) {
//  [0]=>
//  string(6) "Archer"
//  [1]=>
//  string(4) "Kirk"
//  [2]=>
//  string(5) "Sisko"
//  [3]=>
//  string(6) "Picard"
//  [4]=>
//  string(7) "Janeway"
//}
var_dump($redis->sMembers('captains-backup'));
?>

Will return an array with the role of the connected instance unless there is an error.

The source key to pop from.

The destination key to push to.

The popped element or false if the source key was empty.

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

$redis->pipeline()
      ->del('list1', 'list2')
      ->rpush('list1', 'list1-1', 'list1-2')
      ->rpush('list2', 'list2-1', 'list2-2')
      ->exec();

var_dump($redis->rpoplpush('list2', 'list1'));
var_dump($redis->lrange('list1', 0, -1));

// --- OUTPUT ---
// string(7) "list2-2"
//
// array(3) {
//   [0]=>
//   string(7) "list2-2"
//   [1]=>
//   string(7) "list1-1"
//   [2]=>
//   string(7) "list1-2"
// }
?>

The key name

The number of values added to the set.

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

$redis->del('myset');

var_dump($redis->sadd('myset', 'foo', 'bar', 'baz'));
var_dump($redis->sadd('myset', 'foo', 'new'));

// --- OUTPUT ---
// int(3)
// int(1)
?>

The set to add values to.

One or more members to add to the set.

The number of members added to the set.

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

$redis->del('myset');

var_dump($redis->sAddArray('myset', ['foo', 'bar', 'baz']));
var_dump($redis->sAddArray('myset', ['foo', 'new']));

// --- OUTPUT ---
// int(3)
// int(1)
?>

The first set

One or more additional sets

Returns the elements from keys 2..N that don't exist in the first sorted set, or false on failure.

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

$redis->pipeline()
      ->del('set1', 'set2', 'set3')
      ->sadd('set1', 'apple', 'banana', 'carrot', 'date')
      ->sadd('set2', 'carrot')
      ->sadd('set3', 'apple', 'carrot', 'eggplant')
      ->exec();

// NOTE:  'banana' and 'date' are in set1 but none of the subsequent sets.
var_dump($redis->sdiff('set1', 'set2', 'set3'));

// --- OUTPUT ---
array(2) {
  [0]=>
  string(6) "banana"
  [1]=>
  string(4) "date"
}
?>

The key where to store the result

The first key to perform the DIFF on

One or more additional keys.

The number of values stored in the destination set or false on failure.

The first SET key to intersect.

One or more Redis SET keys.

<?php

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

$redis->pipeline()
      ->del('alice_likes', 'bob_likes', 'bill_likes')
      ->sadd('alice_likes', 'asparagus', 'broccoli', 'carrot', 'potato')
      ->sadd('bob_likes', 'asparagus', 'carrot', 'potato')
      ->sadd('bill_likes', 'broccoli', 'potato')
      ->exec();

// NOTE:  'potato' is the only value in all three sets
var_dump($redis->sinter('alice_likes', 'bob_likes', 'bill_likes'));

// --- OUTPUT ---
// array(1) {
//   [0]=>
//   string(6) "potato"
// }
?>

One or more set key names.

A maximum cardinality to return. This is useful to put an upper bound on the amount of work Redis will do.

The

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

$redis->del('set1', 'set2', 'set3');

$redis->sAdd('set1', 'apple', 'pear', 'banana', 'carrot');
$redis->sAdd('set2', 'apple',         'banana');
$redis->sAdd('set3',          'pear', 'banana');

// int(1)
var_dump($redis->sInterCard(['set1', 'set2', 'set3']));
?>

If the first argument was a string, subsequent arguments should be source key names.

The number of values stored in the destination key or false on failure.

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

// OPTION 1:  A single array
$redis->sInterStore(['dst', 'src1', 'src2', 'src3']);

// OPTION 2:  Variadic
$redis->sInterStore('dst', 'src1', 'src'2', 'src3');
?>

The set name.

Every element in the set or false on failure.

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

$redis->del('tng-crew');

$redis->sAdd('tng-crew', ...['Picard', 'Riker', 'Data', 'Worf', 'La Forge', 'Troi', 'Crusher', 'Broccoli']);

// Array
// (
//     [0] => Riker
//     [1] => Crusher
//     [2] => Troi
//     [3] => Worf
//     [4] => LaForge
//     [5] => Picard
//     [6] => Broccoli
//     [7] => Data
// )
$redis->sMembers('tng-crew');

The set to query.

The first value to test if exists in the set.

Any number of additional values to check.

An array of integers representing whether each passed value was a member of the set.

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

$redis->del('ds9-crew');
$redis->sAdd('ds9-crew', ...["Sisko", "Kira", "Dax", "Worf", "Bashir", "O'Brien"]);

$names = ['Sisko', 'Picard', 'Data', 'Worf'];
$members = $redis->sMIsMember('ds9-crew', ...$names);

// array(4) {
//   ["Sisko"]=>
//   int(1)
//   ["Picard"]=>
//   int(0)
//   ["Data"]=>
//   int(0)
//   ["Worf"]=>
//   int(1)
// }
var_dump(array_combine($names, $members));
?>

The source set.

The destination set.

The member you wish to move.

True if the member was moved, and false if it wasn't in the set.

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

$redis->del('numbers', 'evens');
$redis->sAdd('numbers', 'zero', 'one', 'two', 'three', 'four');

$redis->sMove('numbers', 'evens', 'zero');
$redis->sMove('numbers', 'evens', 'two');
$redis->sMove('numbers', 'evens', 'four');

// array(2) {
//   [0]=>
//   string(5) "three"
//   [1]=>
//   string(3) "one"
// }
var_dump($redis->sMembers('numbers'));

// array(3) {
//   [0]=>
//   string(4) "zero"
//   [1]=>
//   string(3) "two"
//   [2]=>
//   string(4) "four"
// }
var_dump($redis->sMembers('evens'));

?>

The set in question.

An optional number of members to pop. This defaults to removing one element.

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

<?php

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

$redis->del('numbers', 'evens');
$redis->sAdd('numbers', 'zero', 'one', 'two', 'three', 'four');

$redis->sMove('numbers', 'evens', 'zero');
$redis->sMove('numbers', 'evens', 'two');
$redis->sMove('numbers', 'evens', 'four');

// array(2) {
//   [0]=>
//   string(5) "three"
//   [1]=>
//   string(3) "one"
// }
var_dump($redis->sMembers('numbers'));

// array(3) {
//   [0]=>
//   string(4) "zero"
//   [1]=>
//   string(3) "two"
//   [2]=>
//   string(4) "four"
// }
var_dump($redis->sMembers('evens'));
?>

The set to query.

An optional count of members to return.

If this value is positive, Redis will return up to the requested number but with unique elements that will never repeat. This means you may recieve fewer then $count replies.

If the number is negative, Redis will return the exact number requested but the result may contain duplicate elements.

One or more random members or false on failure.

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

$redis->del('elder-gods');

$redis->sAdd('elder-gods', ["Cthulhu", "Azathoth", "Daoloth", "D'endrrah"]);

// A single random member returned.
$rng1 = $redis->sRandMember('elder-gods');

// Up to SCARD `elder-gods` random members returned
$rng2 = $redis->sRandMember('elder-gods', 9999);

// 9999 elements from the set returned with duplicates
$rng3 = $redis->sRandMember('elder-gods', -9999);
?>

The first SET to do a union with

One or more subsequent keys

The union of the one or more input sets or false on failure.

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

$redis->pipeline()
      ->del('set1', 'set2', 'set3')
      ->sadd('set1', 'apple', 'banana', 'carrot')
      ->sadd('set2', 'apple', 'carrot', 'fish')
      ->sadd('set3', 'carrot', 'fig', 'eggplant');

var_dump($redis->sunion('set1', 'set2', 'set3'));

// --- OPUTPUT ---
// array(5) {
//   [0]=>
//   string(6) "banana"
//   [1]=>
//   string(5) "apple"
//   [2]=>
//   string(4) "fish"
//   [3]=>
//   string(6) "carrot"
//   [4]=>
//   string(8) "eggplant"
// }
?>

The destination key

The first source key

One or more additional source keys

The number of elements stored in the destination SET or false on failure.

Returns true unless an error occurs.