RedisCluster

<pre>
// Declaring a cluster with an array of seeds
$redisCluster = new RedisCluster(null,['127.0.0.1:6379']);

// Loading a cluster configuration by name
// In order to load a named array, one must first define the seed nodes in redis.ini.
// The following lines would define the cluster 'mycluster', and be loaded automatically by phpredis.

// # In redis.ini
// redis.clusters.seeds = "mycluster[]=localhost:7000&test[]=localhost:7001"
// redis.clusters.timeout = "mycluster=5"
// redis.clusters.read_timeout = "mycluster=10"
// redis.clusters.auth = "mycluster=password" OR ['user' => 'foo', 'pass' => 'bar] as example

//Then, this cluster can be loaded by doing the following

$redisClusterPro = new RedisCluster('mycluster');
$redisClusterDev = new RedisCluster('test');
</pre>

If key didn't exist, FALSE is returned. Otherwise, the value related to this key is returned.

<pre>
$redisCluster->get('key');
</pre>

If you pass an integer, phpredis will redirect to SETEX, and will try to use Redis

= 2.6.12 extended options if you pass an array with valid values.

TRUE if the command is successful.

<pre>
// Simple key -> value set
$redisCluster->set('key', 'value');

// Will redirect, and actually make an SETEX call
$redisCluster->set('key','value', 10);

// Will set the key, if it doesn't exist, with a ttl of 10 seconds
$redisCluster->set('key', 'value', Array('nx', 'ex'=>10));

// Will set a key, if it does exist, with a ttl of 1000 milliseconds
$redisCluster->set('key', 'value', Array('xx', 'px'=>1000));
</pre>

<pre>
$redisCluster->del('x', 'y', 'z', 'h');    // remove x y z
$redisCluster->mset(array('x' => 'a', 'y' => 'b', 'z' => 'c'));
$redisCluster->hset('h', 'field', 'value');
var_dump($redisCluster->mget(array('x', 'y', 'z', 'h')));
// Output:
// array(3) {
// [0]=>
// string(1) "a"
// [1]=>
// string(1) "b"
// [2]=>
// string(1) "c"
// [3]=>
// bool(false)
// }
</pre>

Pairs: array(key => value, ...)

TRUE in case of success, FALSE in case of failure.

<pre>
$redisCluster->mset(array('key0' => 'value0', 'key1' => 'value1'));
var_dump($redisCluster->get('key0'));
var_dump($redisCluster->get('key1'));
// Output:
// string(6) "value0"
// string(6) "value1"
</pre>

1 (if the keys were set) or 0 (no key was set)

An array of keys, or an undefined number of parameters, each a key: key1 key2 key3 ... keyN

Number of keys deleted.

<pre>
$redisCluster->set('key1', 'val1');
$redisCluster->set('key2', 'val2');
$redisCluster->set('key3', 'val3');
$redisCluster->set('key4', 'val4');
$redisCluster->del('key1', 'key2');          // return 2
$redisCluster->del(array('key3', 'key4'));   // return 2
</pre>

TRUE if the command is successful.

<pre>
$redisCluster->setex('key', 3600, 'value'); // sets key → value, with 1h TTL.
</pre>

TRUE if the command is successful.

<pre>
$redisCluster->psetex('key', 1000, 'value'); // sets key → value, with 1s TTL.
</pre>

TRUE in case of success, FALSE in case of failure.

<pre>
$redisCluster->setnx('key', 'value');   // return TRUE
$redisCluster->setnx('key', 'value');   // return FALSE
</pre>

A string, the previous value located at this key.

<pre>
$redisCluster->set('x', '42');
$exValue = $redisCluster->getSet('x', 'lol');   // return '42', replaces x by 'lol'
$newValue = $redisCluster->get('x');            // return 'lol'
</pre>

If the key exists, return TRUE, otherwise return FALSE.

<pre>
$redisCluster->set('key', 'value');
$redisCluster->exists('key');               //  TRUE
$redisCluster->exists('NonExistingKey');    // FALSE
</pre>

pattern, using '*' as a wildcard.

of STRING: The keys that match a certain pattern.

<pre>
$allKeys = $redisCluster->keys('*');   // all keys will match this.
$keyWithUserPrefix = $redisCluster->keys('user*');
</pre>

Depending on the type of the data pointed by the key, this method will return the following value:

• string: RedisCluster::REDIS_STRING
• set: RedisCluster::REDIS_SET
• list: RedisCluster::REDIS_LIST
• zset: RedisCluster::REDIS_ZSET
• hash: RedisCluster::REDIS_HASH
• other: RedisCluster::REDIS_NOT_FOUND

$redisCluster->type('key');

if command executed successfully BOOL FALSE in case of failure (empty list)

<pre>
$redisCluster->rPush('key1', 'A');
$redisCluster->rPush('key1', 'B');
$redisCluster->rPush('key1', 'C');
var_dump( $redisCluster->lRange('key1', 0, -1) );
// Output:
// array(3) {
//   [0]=> string(1) "A"
//   [1]=> string(1) "B"
//   [2]=> string(1) "C"
// }
$redisCluster->lPop('key1');
var_dump( $redisCluster->lRange('key1', 0, -1) );
// Output:
// array(2) {
//   [0]=> string(1) "B"
//   [1]=> string(1) "C"
// }
</pre>

if command executed successfully BOOL FALSE in case of failure (empty list)

<pre>
$redisCluster->rPush('key1', 'A');
$redisCluster->rPush('key1', 'B');
$redisCluster->rPush('key1', 'C');
var_dump( $redisCluster->lRange('key1', 0, -1) );
// Output:
// array(3) {
//   [0]=> string(1) "A"
//   [1]=> string(1) "B"
//   [2]=> string(1) "C"
// }
$redisCluster->rPop('key1');
var_dump( $redisCluster->lRange('key1', 0, -1) );
// Output:
// array(2) {
//   [0]=> string(1) "A"
//   [1]=> string(1) "B"
// }
</pre>

TRUE if the new value is setted. FALSE if the index is out of range, or data type identified by key is not a list.

<pre>
$redisCluster->rPush('key1', 'A');
$redisCluster->rPush('key1', 'B');
$redisCluster->rPush('key1', 'C');  // key1 => [ 'A', 'B', 'C' ]
$redisCluster->lGet('key1', 0);     // 'A'
$redisCluster->lSet('key1', 0, 'X');
$redisCluster->lGet('key1', 0);     // 'X'
</pre>

"popped" value bool FALSE if set identified by key is empty or doesn't exist.

<pre>
$redisCluster->sAdd('key1' , 'set1');
$redisCluster->sAdd('key1' , 'set2');
$redisCluster->sAdd('key1' , 'set3');
var_dump($redisCluster->sMembers('key1'));// 'key1' => {'set3', 'set1', 'set2'}
$redisCluster->sPop('key1');// 'set1'
var_dump($redisCluster->sMembers('key1'));// 'key1' => {'set3', 'set2'}
$redisCluster->sPop('key1');// 'set3',
var_dump($redisCluster->sMembers('key1'));// 'key1' => {'set2'}
</pre>

String, value to push in key

The new length of the list in case of success, FALSE in case of Failure.

<pre>
$redisCluster->lPush('l', 'v1', 'v2', 'v3', 'v4')   // int(4)
var_dump( $redisCluster->lRange('l', 0, -1) );
//// Output:
// array(4) {
//   [0]=> string(2) "v4"
//   [1]=> string(2) "v3"
//   [2]=> string(2) "v2"
//   [3]=> string(2) "v1"
// }
</pre>

String, value to push in key

The new length of the list in case of success, FALSE in case of Failure.

<pre>
$redisCluster->rPush('r', 'v1', 'v2', 'v3', 'v4');    // int(4)
var_dump( $redisCluster->lRange('r', 0, -1) );
//// Output:
// array(4) {
//   [0]=> string(2) "v1"
//   [1]=> string(2) "v2"
//   [2]=> string(2) "v3"
//   [3]=> string(2) "v4"
// }
</pre>

Array containing the keys of the lists Or STRING Key1 STRING Key2 STRING Key3 ... STRING Keyn

array('listName', 'element')

<pre>
// Non blocking feature
$redisCluster->lPush('key1', 'A');
$redisCluster->del('key2');

$redisCluster->blPop('key1', 'key2', 10); // array('key1', 'A')
// OR
$redisCluster->blPop(array('key1', 'key2'), 10); // array('key1', 'A')

$redisCluster->brPop('key1', 'key2', 10); // array('key1', 'A')
// OR
$redisCluster->brPop(array('key1', 'key2'), 10); // array('key1', 'A')

// Blocking feature

// process 1
$redisCluster->del('key1');
$redisCluster->blPop('key1', 10);
// blocking for 10 seconds

// process 2
$redisCluster->lPush('key1', 'A');

// process 1
// array('key1', 'A') is returned
</pre>

Array containing the keys of the lists Or STRING Key1 STRING Key2 STRING Key3 ... STRING Keyn

array('listName', 'element')

<pre>
// Non blocking feature
$redisCluster->lPush('key1', 'A');
$redisCluster->del('key2');

$redisCluster->blPop('key1', 'key2', 10); // array('key1', 'A')
// OR
$redisCluster->blPop(array('key1', 'key2'), 10); // array('key1', 'A')

$redisCluster->brPop('key1', 'key2', 10); // array('key1', 'A')
// OR
$redisCluster->brPop(array('key1', 'key2'), 10); // array('key1', 'A')

// Blocking feature

// process 1
$redisCluster->del('key1');
$redisCluster->blPop('key1', 10);
// blocking for 10 seconds

// process 2
$redisCluster->lPush('key1', 'A');

// process 1
// array('key1', 'A') is returned
</pre>

String, value to push in key

The new length of the list in case of success, FALSE in case of Failure.

<pre>
$redisCluster->del('key1');
$redisCluster->rPushx('key1', 'A'); // returns 0
$redisCluster->rPush('key1', 'A'); // returns 1
$redisCluster->rPushx('key1', 'B'); // returns 2
$redisCluster->rPushx('key1', 'C'); // returns 3
// key1 now points to the following list: [ 'A', 'B', 'C' ]
</pre>

String, value to push in key

The new length of the list in case of success, FALSE in case of Failure.

<pre>
$redisCluster->del('key1');
$redisCluster->lPushx('key1', 'A');     // returns 0
$redisCluster->lPush('key1', 'A');      // returns 1
$redisCluster->lPushx('key1', 'B');     // returns 2
$redisCluster->lPushx('key1', 'C');     // returns 3
// key1 now points to the following list: [ 'C', 'B', 'A' ]
</pre>

RedisCluster::BEFORE | RedisCluster::AFTER

The number of the elements in the list, -1 if the pivot didn't exists.

<pre>
$redisCluster->del('key1');
$redisCluster->lInsert('key1', RedisCluster::AFTER, 'A', 'X');    // 0

$redisCluster->lPush('key1', 'A');
$redisCluster->lPush('key1', 'B');
$redisCluster->lPush('key1', 'C');

$redisCluster->lInsert('key1', RedisCluster::BEFORE, 'C', 'X');   // 4
$redisCluster->lRange('key1', 0, -1);                      // array('X', 'C', 'B', 'A')

$redisCluster->lInsert('key1', RedisCluster::AFTER, 'C', 'Y');    // 5
$redisCluster->lRange('key1', 0, -1);                      // array('X', 'C', 'Y', 'B', 'A')

$redisCluster->lInsert('key1', RedisCluster::AFTER, 'W', 'value'); // -1
</pre>

the element at this index Bool FALSE if the key identifies a non-string data type, or no value corresponds to this index in the list Key.

<pre>
$redisCluster->rPush('key1', 'A');
$redisCluster->rPush('key1', 'B');
$redisCluster->rPush('key1', 'C');  // key1 => [ 'A', 'B', 'C' ]
$redisCluster->lGet('key1', 0);     // 'A'
$redisCluster->lGet('key1', -1);    // 'C'
$redisCluster->lGet('key1', 10);    // `FALSE`
</pre>

the number of elements to remove bool FALSE if the value identified by key is not a list.

<pre>
$redisCluster->lPush('key1', 'A');
$redisCluster->lPush('key1', 'B');
$redisCluster->lPush('key1', 'C');
$redisCluster->lPush('key1', 'A');
$redisCluster->lPush('key1', 'A');

$redisCluster->lRange('key1', 0, -1);   // array('A', 'A', 'C', 'B', 'A')
$redisCluster->lRem('key1', 'A', 2);    // 2
$redisCluster->lRange('key1', 0, -1);   // array('C', 'B', 'A')
</pre>

The element that was moved in case of success, FALSE in case of timeout.

The element that was moved in case of success, FALSE in case of failure.

<pre>
$redisCluster->del('x', 'y');

$redisCluster->lPush('x', 'abc');
$redisCluster->lPush('x', 'def');
$redisCluster->lPush('y', '123');
$redisCluster->lPush('y', '456');

// move the last of x to the front of y.
var_dump($redisCluster->rpoplpush('x', 'y'));
var_dump($redisCluster->lRange('x', 0, -1));
var_dump($redisCluster->lRange('y', 0, -1));

////Output:
//
//string(3) "abc"
//array(1) {
//  [0]=>
//  string(3) "def"
//}
//array(3) {
//  [0]=>
//  string(3) "abc"
//  [1]=>
//  string(3) "456"
//  [2]=>
//  string(3) "123"
//}
</pre>

The size of the list identified by Key exists. bool FALSE if the data type identified by Key is not list

<pre>
$redisCluster->rPush('key1', 'A');
$redisCluster->rPush('key1', 'B');
$redisCluster->rPush('key1', 'C');  // key1 => [ 'A', 'B', 'C' ]
$redisCluster->lLen('key1');       // 3
$redisCluster->rPop('key1');
$redisCluster->lLen('key1');       // 2
</pre>

the cardinality (number of elements) of the set, or 0 if key does not exist.

<pre>
$redisCluster->sAdd('key1' , 'set1');
$redisCluster->sAdd('key1' , 'set2');
$redisCluster->sAdd('key1' , 'set3');   // 'key1' => {'set1', 'set2', 'set3'}
$redisCluster->sCard('key1');           // 3
$redisCluster->sCard('keyX');           // 0
</pre>

All elements of the set.

<pre>
$redisCluster->del('s');
$redisCluster->sAdd('s', 'a');
$redisCluster->sAdd('s', 'b');
$redisCluster->sAdd('s', 'a');
$redisCluster->sAdd('s', 'c');
var_dump($redisCluster->sMembers('s'));

////Output:
//
//array(3) {
//  [0]=>
//  string(1) "b"
//  [1]=>
//  string(1) "c"
//  [2]=>
//  string(1) "a"
//}
// The order is random and corresponds to redis' own internal representation of the set structure.
</pre>

TRUE if value is a member of the set at key key, FALSE otherwise.

<pre>
$redisCluster->sAdd('key1' , 'set1');
$redisCluster->sAdd('key1' , 'set2');
$redisCluster->sAdd('key1' , 'set3'); // 'key1' => {'set1', 'set2', 'set3'}

$redisCluster->sIsMember('key1', 'set1'); // TRUE
$redisCluster->sIsMember('key1', 'setX'); // FALSE
</pre>

Required key

Required value

Optional value

Optional value

The number of elements added to the set

<pre>
$redisCluster->sAdd('k', 'v1');                // int(1)
$redisCluster->sAdd('k', 'v1', 'v2', 'v3');    // int(2)
</pre>

Required key

The number of elements added to the set

<pre>
$redisCluster->sAddArray('k', ['v1', 'v2', 'v3']);
//This is a feature in php only. Same as $redisCluster->sAdd('k', 'v1', 'v2', 'v3');
</pre>

The number of elements removed from the set.

<pre>
var_dump( $redisCluster->sAdd('k', 'v1', 'v2', 'v3') );    // int(3)
var_dump( $redisCluster->sRem('k', 'v2', 'v3') );          // int(2)
var_dump( $redisCluster->sMembers('k') );
//// Output:
// array(1) {
//   [0]=> string(2) "v1"
// }
</pre>

Any number of keys corresponding to sets in redis.

of strings: The union of all these sets.

<pre>
$redisCluster->del('s0', 's1', 's2');

$redisCluster->sAdd('s0', '1');
$redisCluster->sAdd('s0', '2');
$redisCluster->sAdd('s1', '3');
$redisCluster->sAdd('s1', '1');
$redisCluster->sAdd('s2', '3');
$redisCluster->sAdd('s2', '4');

var_dump($redisCluster->sUnion('s0', 's1', 's2'));

//// Output:
//
//array(4) {
//  [0]=>
//  string(1) "3"
//  [1]=>
//  string(1) "4"
//  [2]=>
//  string(1) "1"
//  [3]=>
//  string(1) "2"
//}
</pre>

the key to store the diff into.

Any number of keys corresponding to sets in redis.

Any number of keys corresponding to sets in redis.

<pre>
$redisCluster->del('s0', 's1', 's2');

$redisCluster->sAdd('s0', '1');
$redisCluster->sAdd('s0', '2');
$redisCluster->sAdd('s1', '3');
$redisCluster->sAdd('s1', '1');
$redisCluster->sAdd('s2', '3');
$redisCluster->sAdd('s2', '4');

var_dump($redisCluster->sUnionStore('dst', 's0', 's1', 's2'));
var_dump($redisCluster->sMembers('dst'));

//// Output:
//
//int(4)
//array(4) {
//  [0]=>
//  string(1) "3"
//  [1]=>
//  string(1) "4"
//  [2]=>
//  string(1) "1"
//  [3]=>
//  string(1) "2"
//}
</pre>

keys identifying the different sets on which we will apply the intersection.

contain the result of the intersection between those keys. If the intersection between the different sets is empty, the return value will be empty array.

<pre>
$redisCluster->sAdd('key1', 'val1');
$redisCluster->sAdd('key1', 'val2');
$redisCluster->sAdd('key1', 'val3');
$redisCluster->sAdd('key1', 'val4');

$redisCluster->sAdd('key2', 'val3');
$redisCluster->sAdd('key2', 'val4');

$redisCluster->sAdd('key3', 'val3');
$redisCluster->sAdd('key3', 'val4');

var_dump($redisCluster->sInter('key1', 'key2', 'key3'));

// Output:
//
//array(2) {
//  [0]=>
//  string(4) "val4"
//  [1]=>
//  string(4) "val3"
//}
</pre>

the key to store the diff into.

are intersected as in sInter.

The cardinality of the resulting set, or FALSE in case of a missing key.

<pre>
$redisCluster->sAdd('key1', 'val1');
$redisCluster->sAdd('key1', 'val2');
$redisCluster->sAdd('key1', 'val3');
$redisCluster->sAdd('key1', 'val4');

$redisCluster->sAdd('key2', 'val3');
$redisCluster->sAdd('key2', 'val4');

$redisCluster->sAdd('key3', 'val3');
$redisCluster->sAdd('key3', 'val4');

var_dump($redisCluster->sInterStore('output', 'key1', 'key2', 'key3'));
var_dump($redisCluster->sMembers('output'));

//// Output:
//
//int(2)
//array(2) {
//  [0]=>
//  string(4) "val4"
//  [1]=>
//  string(4) "val3"
//}
</pre>

Any number of keys corresponding to sets in redis.

of strings: The difference of the first set will all the others.

<pre>
$redisCluster->del('s0', 's1', 's2');

$redisCluster->sAdd('s0', '1');
$redisCluster->sAdd('s0', '2');
$redisCluster->sAdd('s0', '3');
$redisCluster->sAdd('s0', '4');

$redisCluster->sAdd('s1', '1');
$redisCluster->sAdd('s2', '3');

var_dump($redisCluster->sDiff('s0', 's1', 's2'));

//// Output:
//
//array(2) {
//  [0]=>
//  string(1) "4"
//  [1]=>
//  string(1) "2"
//}
</pre>

the key to store the diff into.

Any number of keys corresponding to sets in redis

The cardinality of the resulting set, or FALSE in case of a missing key.

<pre>
$redisCluster->del('s0', 's1', 's2');

$redisCluster->sAdd('s0', '1');
$redisCluster->sAdd('s0', '2');
$redisCluster->sAdd('s0', '3');
$redisCluster->sAdd('s0', '4');

$redisCluster->sAdd('s1', '1');
$redisCluster->sAdd('s2', '3');

var_dump($redisCluster->sDiffStore('dst', 's0', 's1', 's2'));
var_dump($redisCluster->sMembers('dst'));

//// Output:
//
//int(2)
//array(2) {
//  [0]=>
//  string(1) "4"
//  [1]=>
//  string(1) "2"
//}
</pre>

value(s) from the set bool FALSE if set identified by key is empty or doesn't exist and count argument isn't passed.

<pre>
$redisCluster->sAdd('key1' , 'one');
$redisCluster->sAdd('key1' , 'two');
$redisCluster->sAdd('key1' , 'three');              // 'key1' => {'one', 'two', 'three'}

var_dump( $redisCluster->sRandMember('key1') );     // 'key1' => {'one', 'two', 'three'}

// string(5) "three"

var_dump( $redisCluster->sRandMember('key1', 2) );  // 'key1' => {'one', 'two', 'three'}

// array(2) {
//   [0]=> string(2) "one"
//   [1]=> string(2) "three"
// }
</pre>

<pre>
$redisCluster->set('key', 'value');
$redisCluster->strlen('key'); // 5
</pre>

TRUE if a timeout was removed, FALSE if the key didn’t exist or didn’t have an expiration timer.

$redisCluster->persist('key');

the time left to live in seconds.

$redisCluster->ttl('key');

the time left to live in milliseconds.

$redisCluster->pttl('key');

the set's cardinality

<pre>
$redisCluster->zAdd('key', 0, 'val0');
$redisCluster->zAdd('key', 2, 'val2');
$redisCluster->zAdd('key', 10, 'val10');
$redisCluster->zCard('key');            // 3
</pre>

the size of a corresponding zRangeByScore.

<pre>
$redisCluster->zAdd('key', 0, 'val0');
$redisCluster->zAdd('key', 2, 'val2');
$redisCluster->zAdd('key', 10, 'val10');
$redisCluster->zCount('key', 0, 3); // 2, corresponding to array('val0', 'val2')
</pre>

double or "+inf" or "-inf" as a string

double or "+inf" or "-inf" as a string

The number of values deleted from the sorted set

<pre>
$redisCluster->zAdd('key', 0, 'val0');
$redisCluster->zAdd('key', 2, 'val2');
$redisCluster->zAdd('key', 10, 'val10');
$redisCluster->zRemRangeByScore('key', '0', '3'); // 2
</pre>

<pre>
$redisCluster->zAdd('key', 2.5, 'val2');
$redisCluster->zScore('key', 'val2'); // 2.5
</pre>

Required key

Required score

Required value

Optional score

Optional value

Optional score

Optional value

Number of values added

<pre>
$redisCluster->zAdd('z', 1, 'v2', 2, 'v2', 3, 'v3', 4, 'v4' );  // int(3)
$redisCluster->zRem('z', 'v2', 'v3');                           // int(2)
var_dump( $redisCluster->zRange('z', 0, -1) );

//// Output:
// array(1) {
//   [0]=> string(2) "v4"
// }
</pre>

(double) value that will be added to the member's score

the new value

<pre>
$redisCluster->del('key');
$redisCluster->zIncrBy('key', 2.5, 'member1');// key or member1 didn't exist, so member1's score is to 0 ;
                                             //before the increment and now has the value 2.5
$redisCluster->zIncrBy('key', 1, 'member1');    // 3.5
</pre>

the number of items in a hash, FALSE if the key doesn't exist or isn't a hash.

<pre>
$redisCluster->del('h');
$redisCluster->hSet('h', 'key1', 'hello');
$redisCluster->hSet('h', 'key2', 'plop');
$redisCluster->hLen('h'); // returns 2
</pre>

An array of elements, the keys of the hash. This works like PHP's array_keys().

<pre>
$redisCluster->del('h');
$redisCluster->hSet('h', 'a', 'x');
$redisCluster->hSet('h', 'b', 'y');
$redisCluster->hSet('h', 'c', 'z');
$redisCluster->hSet('h', 'd', 't');
var_dump($redisCluster->hKeys('h'));

//// Output:
//
// array(4) {
// [0]=>
// string(1) "a"
// [1]=>
// string(1) "b"
// [2]=>
// string(1) "c"
// [3]=>
// string(1) "d"
// }
// The order is random and corresponds to redis' own internal representation of the set structure.
</pre>

An array of elements, the values of the hash. This works like PHP's array_values().

<pre>
$redisCluster->del('h');
$redisCluster->hSet('h', 'a', 'x');
$redisCluster->hSet('h', 'b', 'y');
$redisCluster->hSet('h', 'c', 'z');
$redisCluster->hSet('h', 'd', 't');
var_dump($redisCluster->hVals('h'));

//// Output:
//
// array(4) {
//   [0]=>
//   string(1) "x"
//   [1]=>
//   string(1) "y"
//   [2]=>
//   string(1) "z"
//   [3]=>
//   string(1) "t"
// }
// The order is random and corresponds to redis' own internal representation of the set structure.
</pre>

The value, if the command executed successfully BOOL FALSE in case of failure

<pre>
$redisCluster->del('h');
$redisCluster->hSet('h', 'a', 'x');
$redisCluster->hGet('h', 'a'); // 'X'
</pre>

An array of elements, the contents of the hash.

<pre>
$redisCluster->del('h');
$redisCluster->hSet('h', 'a', 'x');
$redisCluster->hSet('h', 'b', 'y');
$redisCluster->hSet('h', 'c', 'z');
$redisCluster->hSet('h', 'd', 't');
var_dump($redisCluster->hGetAll('h'));

//// Output:
//
// array(4) {
//   ["a"]=>
//   string(1) "x"
//   ["b"]=>
//   string(1) "y"
//   ["c"]=>
//   string(1) "z"
//   ["d"]=>
//   string(1) "t"
// }
// The order is random and corresponds to redis' own internal representation of the set structure.
</pre>

If the member exists in the hash table, return TRUE, otherwise return FALSE.

<pre>
$redisCluster->hSet('h', 'a', 'x');
$redisCluster->hExists('h', 'a');               //  TRUE
$redisCluster->hExists('h', 'NonExistingKey');  // FALSE
</pre>

(integer) value that will be added to the member's value

the new value

<pre>
$redisCluster->del('h');
$redisCluster->hIncrBy('h', 'x', 2); // returns 2: h[x] = 2 now.
$redisCluster->hIncrBy('h', 'x', 1); // h[x] ← 2 + 1. Returns 3
</pre>

1 if value didn't exist and was added successfully, 0 if the value was already present and was replaced, FALSE if there was an error.

<pre>
$redisCluster->del('h')
$redisCluster->hSet('h', 'key1', 'hello');  // 1, 'key1' => 'hello' in the hash at "h"
$redisCluster->hGet('h', 'key1');           // returns "hello"

$redisCluster->hSet('h', 'key1', 'plop');   // 0, value was replaced.
$redisCluster->hGet('h', 'key1');           // returns "plop"
</pre>

TRUE if the field was set, FALSE if it was already present.

<pre>
$redisCluster->del('h')
$redisCluster->hSetNx('h', 'key1', 'hello'); // TRUE, 'key1' => 'hello' in the hash at "h"
$redisCluster->hSetNx('h', 'key1', 'world'); // FALSE, 'key1' => 'hello' in the hash at "h". No change since the
field wasn't replaced.
</pre>

Array An array of elements, the values of the specified fields in the hash, with the hash keys as array keys.

<pre>
$redisCluster->del('h');
$redisCluster->hSet('h', 'field1', 'value1');
$redisCluster->hSet('h', 'field2', 'value2');
$redisCluster->hMGet('h', array('field1', 'field2')); // returns array('field1' => 'value1', 'field2' =>
'value2')
</pre>

key → value array

<pre>
$redisCluster->del('user:1');
$redisCluster->hMSet('user:1', array('name' => 'Joe', 'salary' => 2000));
$redisCluster->hIncrBy('user:1', 'salary', 100); // Joe earns 100 more now.
</pre>

Number of deleted fields

<pre>
$redisCluster->hMSet('h',
              array(
                   'f1' => 'v1',
                   'f2' => 'v2',
                   'f3' => 'v3',
                   'f4' => 'v4',
              ));

var_dump( $redisCluster->hDel('h', 'f1') );        // int(1)
var_dump( $redisCluster->hDel('h', 'f2', 'f3') );  // int(2)

var_dump( $redisCluster->hGetAll('h') );

//// Output:
//
//  array(1) {
//    ["f4"]=> string(2) "v4"
//  }
</pre>

<pre>
$redisCluster->hset('h', 'float', 3);
$redisCluster->hset('h', 'int',   3);
var_dump( $redisCluster->hIncrByFloat('h', 'float', 1.5) ); // float(4.5)

var_dump( $redisCluster->hGetAll('h') );

//// Output:
//
// array(2) {
//   ["float"]=>
//   string(3) "4.5"
//   ["int"]=>
//   string(1) "3"
// }
</pre>

The Redis encoded value of the key, or FALSE if the key doesn't exist

<pre>
$redisCluster->set('foo', 'bar');
$val = $redisCluster->dump('foo'); // $val will be the Redis encoded key value
</pre>

the item's score.

<pre>
$redisCluster->del('z');
$redisCluster->zAdd('key', 1, 'one');
$redisCluster->zAdd('key', 2, 'two');
$redisCluster->zRank('key', 'one');     // 0
$redisCluster->zRank('key', 'two');     // 1
$redisCluster->zRevRank('key', 'one');  // 1
$redisCluster->zRevRank('key', 'two');  // 0
</pre>

the item's score

the new value

<pre>
$redisCluster->incr('key1'); // key1 didn't exists, set to 0 before the increment and now has the value 1
$redisCluster->incr('key1'); // 2
$redisCluster->incr('key1'); // 3
$redisCluster->incr('key1'); // 4
</pre>

the new value

<pre>
$redisCluster->decr('key1'); // key1 didn't exists, set to 0 before the increment and now has the value -1
$redisCluster->decr('key1'); // -2
$redisCluster->decr('key1'); // -3
</pre>

value that will be added to key (only for incrBy)

the new value

<pre>
$redisCluster->incr('key1');        // key1 didn't exists, set to 0 before the increment and now has the value 1
$redisCluster->incr('key1');        // 2
$redisCluster->incr('key1');        // 3
$redisCluster->incr('key1');        // 4
$redisCluster->incrBy('key1', 10);  // 14
</pre>

that will be subtracted to key (only for decrBy)

the new value

<pre>
$redisCluster->decr('key1');        // key1 didn't exists, set to 0 before the increment and now has the value -1
$redisCluster->decr('key1');        // -2
$redisCluster->decr('key1');        // -3
$redisCluster->decrBy('key1', 10);  // -13
</pre>

<pre>
$redisCluster->set('x', 3);
var_dump( $redisCluster->incrByFloat('x', 1.5) );   // float(4.5)

var_dump( $redisCluster->get('x') );                // string(3) "4.5"
</pre>

The key that will disappear.

The key's remaining Time To Live, in seconds.

TRUE in case of success, FALSE in case of failure.

<pre>
$redisCluster->set('x', '42');
$redisCluster->expire('x', 3);  // x will disappear in 3 seconds.
sleep(5);                    // wait 5 seconds
$redisCluster->get('x');            // will return `FALSE`, as 'x' has expired.
</pre>

The key that will disappear.

The key's remaining Time To Live, in milliseconds.

TRUE in case of success, FALSE in case of failure.

<pre>
$redisCluster->set('x', '42');
$redisCluster->pExpire('x', 11500); // x will disappear in 11500 milliseconds.
$redisCluster->ttl('x');            // 12
$redisCluster->pttl('x');           // 11500
</pre>

The key that will disappear.

Unix timestamp. The key's date of death, in seconds from Epoch time.

TRUE in case of success, FALSE in case of failure.

<pre>
$redisCluster->set('x', '42');
$now = time();               // current timestamp
$redisCluster->expireAt('x', $now + 3); // x will disappear in 3 seconds.
sleep(5);                        // wait 5 seconds
$redisCluster->get('x');                // will return `FALSE`, as 'x' has expired.
</pre>

The key that will disappear.

Unix timestamp. The key's date of death, in seconds from Epoch time.

TRUE in case of success, FALSE in case of failure.

<pre>
$redisCluster->set('x', '42');
$redisCluster->pExpireAt('x', 1555555555005);
$redisCluster->ttl('x');                       // 218270121
$redisCluster->pttl('x');                      // 218270120575
</pre>

Size of the value after the append

<pre>
$redisCluster->set('key', 'value1');
$redisCluster->append('key', 'value2'); // 12
$redisCluster->get('key');              // 'value1value2'
</pre>

the bit value (0 or 1)

<pre>
$redisCluster->set('key', "\x7f");  // this is 0111 1111
$redisCluster->getBit('key', 0);    // 0
$redisCluster->getBit('key', 1);    // 1
</pre>

bool or int (1 or 0)

0 or 1, the value of the bit before it was set.

<pre>
$redisCluster->set('key', "*");     // ord("*") = 42 = 0x2f = "0010 1010"
$redisCluster->setBit('key', 5, 1); // returns 0
$redisCluster->setBit('key', 7, 1); // returns 0
$redisCluster->get('key');          // chr(0x2f) = "/" = b("0010 1111")
</pre>

either "AND", "OR", "NOT", "XOR"

return key

The size of the string stored in the destination key.

<pre>
$redisCluster->set('bit1', '1'); // 11 0001
$redisCluster->set('bit2', '2'); // 11 0010

$redisCluster->bitOp('AND', 'bit', 'bit1', 'bit2'); // bit = 110000
$redisCluster->bitOp('OR',  'bit', 'bit1', 'bit2'); // bit = 110011
$redisCluster->bitOp('NOT', 'bit', 'bit1', 'bit2'); // bit = 110011
$redisCluster->bitOp('XOR', 'bit', 'bit1', 'bit2'); // bit = 11
</pre>

The command returns the position of the first bit set to 1 or 0 according to the request. If we look for set bits (the bit argument is 1) and the string is empty or composed of just zero bytes, -1 is returned. If we look for clear bits (the bit argument is 0) and the string only contains bit set to 1, the function returns the first bit not part of the string on the right. So if the string is three bytes set to the value 0xff the command BITPOS key 0 will return 24, since up to bit 23 all the bits are 1. Basically, the function considers the right of the string as padded with zeros if you look for clear bits and specify no range or the start argument only. However, this behavior changes if you are looking for clear bits and specify a range with both start and end. If no clear bit is found in the specified range, the function returns -1 as the user specified a clear range and there are no 0 bits in that range.

<pre>
$redisCluster->set('key', '\xff\xff');
$redisCluster->bitpos('key', 1); // int(0)
$redisCluster->bitpos('key', 1, 1); // int(8)
$redisCluster->bitpos('key', 1, 3); // int(-1)
$redisCluster->bitpos('key', 0); // int(16)
$redisCluster->bitpos('key', 0, 1); // int(16)
$redisCluster->bitpos('key', 0, 1, 5); // int(-1)
</pre>

The number of bits set to 1 in the value behind the input key.

<pre>
$redisCluster->set('bit', '345'); // // 11 0011  0011 0100  0011 0101
var_dump( $redisCluster->bitCount('bit', 0, 0) ); // int(4)
var_dump( $redisCluster->bitCount('bit', 1, 1) ); // int(3)
var_dump( $redisCluster->bitCount('bit', 2, 2) ); // int(4)
var_dump( $redisCluster->bitCount('bit', 0, 2) ); // int(11)
</pre>

the substring

<pre>
$redisCluster->set('key', 'string value');
$redisCluster->getRange('key', 0, 5);   // 'string'
$redisCluster->getRange('key', -5, -1); // 'value'
</pre>

Bool return FALSE if the key identify a non-list value.

<pre>
$redisCluster->rPush('key1', 'A');
$redisCluster->rPush('key1', 'B');
$redisCluster->rPush('key1', 'C');
$redisCluster->lRange('key1', 0, -1); // array('A', 'B', 'C')
$redisCluster->lTrim('key1', 0, 1);
$redisCluster->lRange('key1', 0, -1); // array('A', 'B')
</pre>

containing the values in specified range.

<pre>
$redisCluster->rPush('key1', 'A');
$redisCluster->rPush('key1', 'B');
$redisCluster->rPush('key1', 'C');
$redisCluster->lRange('key1', 0, -1); // array('A', 'B', 'C')
</pre>

The number of values deleted from the sorted set

<pre>
$redisCluster->zAdd('key', 1, 'one');
$redisCluster->zAdd('key', 2, 'two');
$redisCluster->zAdd('key', 3, 'three');
$redisCluster->zRemRangeByRank('key', 0, 1); // 2
$redisCluster->zRange('key', 0, -1, true); // array('three' => 3)
</pre>

a channel to publish to

Number of clients that received the message

$redisCluster->publish('chan-1', 'hello, world!'); // send message.

TRUE in case of success, FALSE in case of failure.

<pre>
$redisCluster->set('x', '42');
$redisCluster->rename('x', 'y');
$redisCluster->get('y');   // → 42
$redisCluster->get('x');   // → `FALSE`
</pre>

TRUE in case of success, FALSE in case of failure.

<pre>
$redisCluster->set('x', '42');
$redisCluster->renameNx('x', 'y');
$redisCluster->get('y');   // → 42
$redisCluster->get('x');   // → `FALSE`
</pre>

<pre>
$redisCluster->pfAdd('key1', array('elem1', 'elem2'));
$redisCluster->pfAdd('key2', array('elem3', 'elem2'));
$redisCluster->pfCount('key1'); // int(2)
$redisCluster->pfCount(array('key1', 'key2')); // int(3)
</pre>

$redisCluster->pfAdd('key', array('elem1', 'elem2'))

<pre>
$redisCluster->pfAdd('key1', array('elem1', 'elem2'));
$redisCluster->pfAdd('key2', array('elem3', 'elem2'));
$redisCluster->pfMerge('key3', array('key1', 'key2'));
$redisCluster->pfCount('key3'); // int(3)
</pre>

the length of the string after it was modified.

<pre>
$redisCluster->set('key', 'Hello world');
$redisCluster->setRange('key', 6, "redis"); // returns 11
$redisCluster->get('key');                  // "Hello redis"
</pre>

The key name

How long the key should live (if zero, no expire will be set on the key)

(binary). The Redis encoded key value (from DUMP)

<pre>
$redisCluster->set('foo', 'bar');
$val = $redisCluster->dump('foo');
$redisCluster->restore('bar', 0, $val); // The key 'bar', will now be equal to the key 'foo'
</pre>

If the operation is successful, return TRUE. If the srcKey and/or dstKey didn't exist, and/or the member didn't exist in srcKey, FALSE is returned.

<pre>
$redisCluster->sAdd('key1' , 'set11');
$redisCluster->sAdd('key1' , 'set12');
$redisCluster->sAdd('key1' , 'set13');          // 'key1' => {'set11', 'set12', 'set13'}
$redisCluster->sAdd('key2' , 'set21');
$redisCluster->sAdd('key2' , 'set22');          // 'key2' => {'set21', 'set22'}
$redisCluster->sMove('key1', 'key2', 'set13');  // 'key1' =>  {'set11', 'set12'}
                                         // 'key2' =>  {'set21', 'set22', 'set13'}
</pre>

Array containing the values in specified range.

<pre>
$redisCluster->zAdd('key1', 0, 'val0');
$redisCluster->zAdd('key1', 2, 'val2');
$redisCluster->zAdd('key1', 10, 'val10');
$redisCluster->zRange('key1', 0, -1); // array('val0', 'val2', 'val10')
// with scores
$redisCluster->zRange('key1', 0, -1, true); // array('val0' => 0, 'val2' => 2, 'val10' => 10)
</pre>

Array containing the values in specified range.

<pre>
$redisCluster->zAdd('key', 0, 'val0');
$redisCluster->zAdd('key', 2, 'val2');
$redisCluster->zAdd('key', 10, 'val10');
$redisCluster->zRevRange('key', 0, -1); // array('val10', 'val2', 'val0')

// with scores
$redisCluster->zRevRange('key', 0, -1, true); // array('val10' => 10, 'val2' => 2, 'val0' => 0)
</pre>

Two options are available:

• withscores => TRUE,
• and limit => array($offset, $count)

Array containing the values in specified range.

<pre>
$redisCluster->zAdd('key', 0, 'val0');
$redisCluster->zAdd('key', 2, 'val2');
$redisCluster->zAdd('key', 10, 'val10');
$redisCluster->zRangeByScore('key', 0, 3);
// array('val0', 'val2')
$redisCluster->zRangeByScore('key', 0, 3, array('withscores' => TRUE);
// array('val0' => 0, 'val2' => 2)
$redisCluster->zRangeByScore('key', 0, 3, array('limit' => array(1, 1));
// array('val2' => 2)
$redisCluster->zRangeByScore('key', 0, 3, array('limit' => array(1, 1));
// array('val2')
$redisCluster->zRangeByScore('key', 0, 3, array('withscores' => TRUE, 'limit' => array(1, 1));
// array('val2'=> 2)
</pre>

The ZSET you wish to run against.

The minimum alphanumeric value you wish to get.

The maximum alphanumeric value you wish to get.

Optional argument if you wish to start somewhere other than the first element.

Optional argument if you wish to limit the number of elements returned.

Array containing the values in the specified range.

<pre>
foreach (array('a', 'b', 'c', 'd', 'e', 'f', 'g') as $k => $char) {
    $redisCluster->zAdd('key', $k, $char);
}

$redisCluster->zRangeByLex('key', '-', '[c'); // array('a', 'b', 'c')
$redisCluster->zRangeByLex('key', '-', '(c'); // array('a', 'b')
$redisCluster->zRevRangeByLex('key', '(c','-'); // array('b', 'a')
</pre>

The number of elements in the specified score range.

<pre>
foreach (array('a', 'b', 'c', 'd', 'e', 'f', 'g') as $k => $char) {
    $redisCluster->zAdd('key', $k, $char);
}
$redisCluster->zLexCount('key', '[b', '[f'); // 5
</pre>

The ZSET you wish to run against.

The minimum alphanumeric value you wish to get.

The maximum alphanumeric value you wish to get.

the number of elements removed.

<pre>
foreach (array('a', 'b', 'c', 'd', 'e', 'f', 'g') as $k => $char) {
    $redisCluster->zAdd('key', $k, $char);
}
$redisCluster->zRemRangeByLex('key', '(b','[d'); // 2 , remove element 'c' and 'd'
$redisCluster->zRange('key',0,-1);// array('a','b','e','f','g')
</pre>

Either "SUM", "MIN", or "MAX": defines the behaviour to use on duplicate entries during the zUnion.

The number of values in the new sorted set.

<pre>
$redisCluster->del('k1');
$redisCluster->del('k2');
$redisCluster->del('k3');
$redisCluster->del('ko1');
$redisCluster->del('ko2');
$redisCluster->del('ko3');

$redisCluster->zAdd('k1', 0, 'val0');
$redisCluster->zAdd('k1', 1, 'val1');

$redisCluster->zAdd('k2', 2, 'val2');
$redisCluster->zAdd('k2', 3, 'val3');

$redisCluster->zUnionStore('ko1', array('k1', 'k2')); // 4, 'ko1' => array('val0', 'val1', 'val2', 'val3')

// Weighted zUnionStore
$redisCluster->zUnionStore('ko2', array('k1', 'k2'), array(1, 1)); // 4, 'ko2' => array('val0', 'val1', 'val2','val3')
$redisCluster->zUnionStore('ko3', array('k1', 'k2'), array(5, 1)); // 4, 'ko3' => array('val0', 'val2', 'val3','val1')
</pre>

Either "SUM", "MIN", or "MAX": defines the behaviour to use on duplicate entries during the zInterStore.

The number of values in the new sorted set.

<pre>
$redisCluster->del('k1');
$redisCluster->del('k2');
$redisCluster->del('k3');

$redisCluster->del('ko1');
$redisCluster->del('ko2');
$redisCluster->del('ko3');
$redisCluster->del('ko4');

$redisCluster->zAdd('k1', 0, 'val0');
$redisCluster->zAdd('k1', 1, 'val1');
$redisCluster->zAdd('k1', 3, 'val3');

$redisCluster->zAdd('k2', 2, 'val1');
$redisCluster->zAdd('k2', 3, 'val3');

$redisCluster->zInterStore('ko1', array('k1', 'k2'));               // 2, 'ko1' => array('val1', 'val3')
$redisCluster->zInterStore('ko2', array('k1', 'k2'), array(1, 1));  // 2, 'ko2' => array('val1', 'val3')

// Weighted zInterStore
$redisCluster->zInterStore('ko3', array('k1', 'k2'), array(1, 5), 'min'); // 2, 'ko3' => array('val1', 'val3')
$redisCluster->zInterStore('ko4', array('k1', 'k2'), array(1, 5), 'max'); // 2, 'ko4' => array('val3', 'val1')
</pre>

Number of deleted values

<pre>
$redisCluster->zAdd('z', 1, 'v1', 2, 'v2', 3, 'v3', 4, 'v4' );  // int(2)
$redisCluster->zRem('z', 'v2', 'v3');                           // int(2)
var_dump( $redisCluster->zRange('z', 0, -1) );
//// Output:
//
// array(2) {
//   [0]=> string(2) "v1"
//   [1]=> string(2) "v4"
// }
</pre>

array(key => value, ...) - optional, with the following keys and values:

• 'by' => 'somepattern*',
• 'limit' => array(0, 1),
• 'get' => 'some_otherpattern*' or an array of patterns,
• 'sort' => 'asc' or 'desc',
• 'alpha' => TRUE,
• 'store' => 'external-key'

An array of values, or a number corresponding to the number of elements stored if that was used.

<pre>
$redisCluster->del('s');
$redisCluster->sadd('s', 5);
$redisCluster->sadd('s', 4);
$redisCluster->sadd('s', 2);
$redisCluster->sadd('s', 1);
$redisCluster->sadd('s', 3);

var_dump($redisCluster->sort('s')); // 1,2,3,4,5
var_dump($redisCluster->sort('s', array('sort' => 'desc'))); // 5,4,3,2,1
var_dump($redisCluster->sort('s', array('sort' => 'desc', 'store' => 'out'))); // (int)5
</pre>

for "encoding", int for "refcount" and "idletime", FALSE if the key doesn't exist.

<pre>
$redisCluster->object("encoding", "l"); // → ziplist
$redisCluster->object("refcount", "l"); // → 1
$redisCluster->object("idletime", "l"); // → 400 (in seconds, with a precision of 10 seconds).
</pre>

an array of channels to subscribe to

either a string or an array($instance, 'method_name'). The callback function receives 3 parameters: the redis instance, the channel name, and the message.

Any non-null return value in the callback will be returned to the caller.

<pre>
function f($redisCluster, $chan, $msg) {
 switch($chan) {
     case 'chan-1':
         ...
         break;

     case 'chan-2':
                    ...
         break;

     case 'chan-2':
         ...
         break;
     }
}

$redisCluster->subscribe(array('chan-1', 'chan-2', 'chan-3'), 'f'); // subscribe to 3 chans
</pre>

The number of elements removed from the set.

Either a string or an array with an object and method. The callback will get four arguments ($redis, $pattern, $channel, $message)

Any non-null return value in the callback will be returned to the caller.

<pre>
function psubscribe($redisCluster, $pattern, $chan, $msg) {
 echo "Pattern: $pattern\n";
 echo "Channel: $chan\n";
 echo "Payload: $msg\n";
}
</pre>

<pre>
$script = 'return 1';
$sha = $redisCluster->script('load', $script);
$redisCluster->evalSha($sha); // Returns 1
</pre>

Iterator, initialized to NULL.

Node identified by key or host/port array

Pattern to match.

Count of keys per iteration (only a suggestion to Redis).

This function will return an array of keys or FALSE if there are no more keys.

<pre>
$iterator = null;
while($keys = $redisCluster->scan($iterator)) {
    foreach($keys as $key) {
        echo $key . PHP_EOL;
    }
}
</pre>

The set to search.

LONG (reference) to the iterator as we go.

String, optional pattern to match against.

How many members to return at a time (Redis might return a different amount).

PHPRedis will return an array of keys or FALSE when we're done iterating.

<pre>
$iterator = null;
while ($members = $redisCluster->sScan('set', $iterator)) {
    foreach ($members as $member) {
        echo $member . PHP_EOL;
    }
}
</pre>

String, the set to scan.

Long (reference), initialized to NULL.

String (optional), the pattern to match.

How many keys to return per iteration (Redis might return a different number).

PHPRedis will return matching keys from Redis, or FALSE when iteration is complete.

<pre>
$iterator = null;
while ($members = $redis-zscan('zset', $iterator)) {
    foreach ($members as $member => $score) {
        echo $member . ' => ' . $score . PHP_EOL;
    }
}
</pre>

Optional pattern to match against.

How many keys to return in a go (only a sugestion to Redis).

An array of members that match our pattern.

<pre>
$iterator = null;
while($elements = $redisCluster->hscan('hash', $iterator)) {
   foreach($elements as $key => $value) {
        echo $key . ' => ' . $value . PHP_EOL;
    }
}
</pre>

Either RedisCluster::ATOMIC, RedisCluster::MULTI or RedisCluster::PIPELINE

$redisCluster->getMode();

A string with the last returned script based error message, or NULL if there is no error

<pre>
$redisCluster->eval('this-is-not-lua');
$err = $redisCluster->getLastError();
// "ERR Error compiling script (new function): user_script:1: '=' expected near '-'"
</pre>

<pre>
$redisCluster->set('x', 'a');
$redisCluster->incr('x');
$err = $redisCluster->getLastError();
// "ERR value is not an integer or out of range"
$redisCluster->clearLastError();
$err = $redisCluster->getLastError();
// NULL
</pre>

Parameter value.

// return RedisCluster::SERIALIZER_NONE, RedisCluster::SERIALIZER_PHP, or RedisCluster::SERIALIZER_IGBINARY.
$redisCluster->getOption(RedisCluster::OPT_SERIALIZER);

parameter value

TRUE on success, FALSE on error.

<pre>
$redisCluster->setOption(RedisCluster::OPT_SERIALIZER, RedisCluster::SERIALIZER_NONE);        // don't serialize data
$redisCluster->setOption(RedisCluster::OPT_SERIALIZER, RedisCluster::SERIALIZER_PHP);         // use built-in serialize/unserialize
$redisCluster->setOption(RedisCluster::OPT_SERIALIZER, RedisCluster::SERIALIZER_IGBINARY);    // use igBinary serialize/unserialize
$redisCluster->setOption(RedisCluster::OPT_PREFIX, 'myAppName:');                             // use custom prefix on all keys
</pre>

The value you wish to prefix

If a prefix is set up, the value now prefixed. If there is no prefix, the value will be returned unchanged.

<pre>
$redisCluster->setOption(RedisCluster::OPT_PREFIX, 'my-prefix:');
$redisCluster->_prefix('my-value'); // Will return 'my-prefix:my-value'
</pre>

The value to be serialized.

<pre>
$redisCluster->setOption(RedisCluster::OPT_SERIALIZER, RedisCluster::SERIALIZER_NONE);
$redisCluster->_serialize("foo"); // returns "foo"
$redisCluster->_serialize(Array()); // Returns "Array"
$redisCluster->_serialize(new stdClass()); // Returns "Object"

$redisCluster->setOption(RedisCluster::OPT_SERIALIZER, RedisCluster::SERIALIZER_PHP);
$redisCluster->_serialize("foo"); // Returns 's:3:"foo";'
</pre>

The value to be unserialized

<pre>
$redisCluster->setOption(RedisCluster::OPT_SERIALIZER, RedisCluster::SERIALIZER_PHP);
$redisCluster->_unserialize('a:3:{i:0;i:1;i:1;i:2;i:2;i:3;}'); // Will return Array(1,2,3)
</pre>

<pre>
$redisCluster->_masters(); // Will return [[0=>'127.0.0.1','6379'],[0=>'127.0.0.1','6380']]
</pre>

RedisCluster::MULTI|RedisCluster::PIPELINE Defaults to RedisCluster::MULTI. A RedisCluster::MULTI block of commands runs as a single transaction; a RedisCluster::PIPELINE block is simply transmitted faster to the server, but without any guarantee of atomicity. discard cancels a transaction.

returns the RedisCluster instance and enters multi-mode. Once in multi-mode, all subsequent method calls return the same object until exec() is called.

<pre>
$ret = $redisCluster->multi()
     ->set('key1', 'val1')
     ->get('key1')
     ->set('key2', 'val2')
     ->get('key2')
     ->exec();

//$ret == array (
//    0 => TRUE,
//    1 => 'val1',
//    2 => TRUE,
//    3 => 'val2');
</pre>

: a list of keys

<pre>
$redisCluster->watch('x');
// long code here during the execution of which other clients could well modify `x`
$ret = $redisCluster->multi()
         ->incr('x')
         ->exec();
// $ret = FALSE if x has been modified between the call to WATCH and the call to EXEC.
</pre>

key or [host,port]

TRUE in case of success, FALSE in case of failure. If a save is already running, this command will fail and return FALSE.

$redisCluster->save('x'); //key
$redisCluster->save(['127.0.0.1',6379]); //[host,port]

key or [host,port]

TRUE in case of success, FALSE in case of failure. If a save is already running, this command will fail and return FALSE.

key or [host,port]

Always TRUE.

key or [host,port]

Always TRUE.

key or [host,port]

DB size, in number of keys.

<pre>
$count = $redisCluster->dbSize('x');
echo "Redis has $count keys\n";
</pre>

key or [host,port]

TRUE in case of success, FALSE in case of failure.

$redisCluster->bgrewriteaof('x');

key or [host,port]

$redisCluster->lastSave('x');

Optional. The option to provide redis. SERVER | CLIENTS | MEMORY | PERSISTENCE | STATS | REPLICATION | CPU | CLASTER | KEYSPACE | COMANDSTATS

Returns an associative array of strings and integers, with the following keys:

• redis_version
• redis_git_sha1
• redis_git_dirty
• redis_build_id
• redis_mode
• os
• arch_bits
• multiplexing_api
• atomicvar_api
• gcc_version
• process_id
• run_id
• tcp_port
• uptime_in_seconds
• uptime_in_days
• hz
• lru_clock
• executable
• config_file
• connected_clients
• client_longest_output_list
• client_biggest_input_buf
• blocked_clients
• used_memory
• used_memory_human
• used_memory_rss
• used_memory_rss_human
• used_memory_peak
• used_memory_peak_human
• used_memory_peak_perc
• used_memory_peak
• used_memory_overhead
• used_memory_startup
• used_memory_dataset
• used_memory_dataset_perc
• total_system_memory
• total_system_memory_human
• used_memory_lua
• used_memory_lua_human
• maxmemory
• maxmemory_human
• maxmemory_policy
• mem_fragmentation_ratio
• mem_allocator
• active_defrag_running
• lazyfree_pending_objects
• mem_fragmentation_ratio
• loading
• rdb_changes_since_last_save
• rdb_bgsave_in_progress
• rdb_last_save_time
• rdb_last_bgsave_status
• rdb_last_bgsave_time_sec
• rdb_current_bgsave_time_sec
• rdb_last_cow_size
• aof_enabled
• aof_rewrite_in_progress
• aof_rewrite_scheduled
• aof_last_rewrite_time_sec
• aof_current_rewrite_time_sec
• aof_last_bgrewrite_status
• aof_last_write_status
• aof_last_cow_size
• changes_since_last_save
• aof_current_size
• aof_base_size
• aof_pending_rewrite
• aof_buffer_length
• aof_rewrite_buffer_length
• aof_pending_bio_fsync
• aof_delayed_fsync
• loading_start_time
• loading_total_bytes
• loading_loaded_bytes
• loading_loaded_perc
• loading_eta_seconds
• total_connections_received
• total_commands_processed
• instantaneous_ops_per_sec
• total_net_input_bytes
• total_net_output_bytes
• instantaneous_input_kbps
• instantaneous_output_kbps
• rejected_connections
• maxclients
• sync_full
• sync_partial_ok
• sync_partial_err
• expired_keys
• evicted_keys
• keyspace_hits
• keyspace_misses
• pubsub_channels
• pubsub_patterns
• latest_fork_usec
• migrate_cached_sockets
• slave_expires_tracked_keys
• active_defrag_hits
• active_defrag_misses
• active_defrag_key_hits
• active_defrag_key_misses
• role
• master_replid
• master_replid2
• master_repl_offset
• second_repl_offset
• repl_backlog_active
• repl_backlog_size
• repl_backlog_first_byte_offset
• repl_backlog_histlen
• master_host
• master_port
• master_link_status
• master_last_io_seconds_ago
• master_sync_in_progress
• slave_repl_offset
• slave_priority
• slave_read_only
• master_sync_left_bytes
• master_sync_last_io_seconds_ago
• master_link_down_since_seconds
• connected_slaves
• min-slaves-to-write
• min-replicas-to-write
• min_slaves_good_slaves
• used_cpu_sys
• used_cpu_user
• used_cpu_sys_children
• used_cpu_user_children
• cluster_enabled

<pre>
$redisCluster->info();

or

$redisCluster->info("COMMANDSTATS"); //Information on the commands that have been run (>=2.6 only)
$redisCluster->info("CPU"); // just CPU information from Redis INFO
</pre>

key or [host,port]

<pre>
$redisCluster->role(['127.0.0.1',6379]);
// [ 0=>'master',1 => 3129659, 2 => [ ['127.0.0.1','9001','3129242'], ['127.0.0.1','9002','3129543'] ] ]
</pre>

key or [host,port]

an existing key in redis.

<pre>
$key = $redisCluster->randomKey('x');
$surprise = $redisCluster->get($key);  // who knows what's in there.
</pre>

key or [host,port]

If successfully, the time will come back as an associative array with element zero being the unix timestamp, and element one being microseconds.

<pre>
var_dump( $redisCluster->time('x') );
//// Output:
//
// array(2) {
//   [0] => string(10) "1342364352"
//   [1] => string(6) "253002"
// }
</pre>

key or [host,port]

STRING: +PONG on success. Throws a RedisClusterException object on connectivity error, as described above.

key or [host,port]

array | bool

key or [host,port]

Required command to send to the server.

Optional variable amount of arguments to send to the server.

key or [host,port]

Required command to send to the server.

Optional variable amount of arguments to send to the server.

<pre>
$redisCluster->cluster(['127.0.0.1',6379],'INFO');
</pre>

key or [host,port]

can be: 'LIST', 'KILL', 'GETNAME', or 'SETNAME'

optional arguments

key or [host,port]

either GET or SET

for SET, glob-pattern for GET. See https://redis.io/commands/config-get for examples.

optional string (only for SET)

Associative array for GET, key -> value

<pre>
$redisCluster->config(['127.0.0.1',6379], "GET", "*max-*-entries*");
$redisCluster->config(['127.0.0.1',6379], "SET", "dir", "/var/run/redis/dumps/");
</pre>

key or [host,port]

String, which can be: "channels", "numsub", or "numpat"

Optional, variant. For the "channels" subcommand, you can pass a string pattern. For "numsub" an array of channel names

Either an integer or an array.

• channels Returns an array where the members are the matching channels.
• numsub Returns a key/value array where the keys are channel names and values are their counts.
• numpat Integer return containing the number active pattern subscriptions.

<pre>
$redisCluster->pubsub(['127.0.0.1',6379], 'channels'); // All channels
$redisCluster->pubsub(['127.0.0.1',6379], 'channels', '*pattern*'); // Just channels matching your pattern
$redisCluster->pubsub(['127.0.0.1',6379], 'numsub', array('chan1', 'chan2')); // Get subscriber counts for
'chan1' and 'chan2'
$redisCluster->pubsub(['127.0.0.1',6379], 'numpat'); // Get the number of pattern subscribers
</pre>

key or [host,port]

load | flush | kill | exists

<pre>
$redisCluster->script(['127.0.0.1',6379], 'load', $script);
$redisCluster->script(['127.0.0.1',6379], 'flush');
$redisCluster->script(['127.0.0.1',6379], 'kill');
$redisCluster->script(['127.0.0.1',6379], 'exists', $script1, [$script2, $script3, ...]);
</pre>

SCRIPT LOAD will return the SHA1 hash of the passed script on success, and FALSE on failure.
SCRIPT FLUSH should always return TRUE
SCRIPT KILL will return true if a script was able to be killed and false if not
SCRIPT EXISTS will return an array with TRUE or FALSE for each passed script

key or [host,port]

<pre>
$redisCluster->slowLog(['127.0.0.1',6379],'get','2');
</pre>

<pre>
$redisCluster->geoAdd('Sicily', 13.361389, 38.115556, 'Palermo'); // int(1)
$redisCluster->geoAdd('Sicily', 15.087269, 37.502669, "Catania"); // int(1)
</pre>

<pre>
$redisCluster->geoAdd('Sicily', 13.361389, 38.115556, 'Palermo'); // int(1)
$redisCluster->geoAdd('Sicily', 15.087269, 37.502669, "Catania"); // int(1)
$redisCluster->geohash('Sicily','Palermo','Catania');//['sqc8b49rny0','sqdtr74hyu0']
</pre>

<pre>
$redisCluster->geoAdd('Sicily', 15.087269, 37.502669, "Catania"); // int(1)
$redisCluster->geopos('Sicily','Palermo');//[['13.36138933897018433','38.11555639549629859']]
</pre>

The unit must be one of the following, and defaults to meters: m for meters. km for kilometers. mi for miles. ft for feet.

<pre>
$redisCluster->geoAdd('Sicily', 13.361389, 38.115556, 'Palermo'); // int(1)
$redisCluster->geoAdd('Sicily', 15.087269, 37.502669, "Catania"); // int(1)
$redisCluster->geoDist('Sicily', 'Palermo' ,'Catania'); // float(166274.1516)
$redisCluster->geoDist('Sicily', 'Palermo','Catania', 'km'); // float(166.2742)
</pre>

String can be: "m" for meters; "km" for kilometers , "mi" for miles, or "ft" for feet.

<pre>
$redisCluster->del('Sicily');
$redisCluster->geoAdd('Sicily', 12.361389, 35.115556, 'Palermo'); // int(1)
$redisCluster->geoAdd('Sicily', 15.087269, 37.502669, "Catania"); // int(1)
$redisCluster->geoAdd('Sicily', 13.3585, 35.330022, "Agrigento"); // int(1)

var_dump( $redisCluster->geoRadius('Sicily',13.3585, 35.330022, 300, 'km', ['WITHDIST' ,'DESC']) );

array(3) {
   [0]=>
  array(2) {
       [0]=>
    string(7) "Catania"
       [1]=>
    string(8) "286.9362"
  }
  [1]=>
  array(2) {
       [0]=>
    string(7) "Palermo"
       [1]=>
    string(7) "93.6874"
  }
  [2]=>
  array(2) {
       [0]=>
    string(9) "Agrigento"
       [1]=>
    string(6) "0.0002"
  }
}
var_dump( $redisCluster->geoRadiusByMember('Sicily','Agrigento', 100, 'km', ['WITHDIST' ,'DESC']) );

* array(2) {
   [0]=>
  array(2) {
       [0]=>
    string(7) "Palermo"
       [1]=>
    string(7) "93.6872"
  }
  [1]=>
  array(2) {
       [0]=>
    string(9) "Agrigento"
       [1]=>
    string(6) "0.0000"
  }
}

<pre>