在 http://www.redis.net.cn/ 能找到所有关于redis的信息,包括安装、命令、在编程语言中的使用等等。这里就不讲如何安装redis了,因为在上面的网站中都能找到。下面直接讲redis是如何在php中使用的,这里我选择的是phpredis扩展。

1. 下载phpredis扩展  

  执行phpinfo()函数,根据下面截图中的“NTS”和“VCn”选择对应的压缩包,https://github.com/phpredis/phpredis/downloads。另外注意,PHP版本也要对应好。

 

2. PHP配置安装扩展

  首先把压缩包中的 php_igbinary.dll和php_redis.dll 文件放到PHP安装目录的 ext 目录中

  然后在 php.ini 添加如下配置

extension=php_igbinary.dll
extension=php_redis.dll

 

3. 重启apache,执行phpinfo()函数,会发现多了redis的扩展。

 

 4. 开启Redis服务,测试

复制代码
    $redis = new Redis();
    //连接redis服务器
    $redis->connect('127.0.0.1', '6379');
    echo "Connection to server sucessfully <br/>";

    //查看服务是否运行
    echo "Server is running: " . $redis->ping();
复制代码

结果如下,连接redis服务器成功

Connection to server sucessfully 
Server is running: +PONG

 

至此,我们可以在php中痛痛快快的使用redis了。

复制代码
 1     $redis = new Redis();
 2     //连接redis服务器
 3     $redis->connect('127.0.0.1', '6379');
 4 
 5 
 6     $key = "key";
 7     $val = "val";
 8 
 9     //redis key操作
10     $redis->exists($key);           //判断key值是否存在
11     $redis->expire($key, 10);       //设置key在10秒后过期
12 
13     //redis string 字符串
14     $redis->set($key, $val);
15     $redis->incr($key);         //key值+1,除非val是整数,否则函数执行失败
16     $redis->decr($key);         //key值-1,同上
17     $redis->append($key, "ue"); //追加key值内容
18     $redis->strlen($key);       //返回key值的长度
19 
20     //当第一次设置key值后,key值的数据类型就不能改变了。
21     $redis->del($key);  //删除key值
22 
23     //redis hash 哈希
24     $redis->hset($key, 'field1', 'val1');   //设置一个key-value键值对
25     $redis->hmset($key, array('field2'=>'val2', 'field3'=>'val3'));    //设置多个k-v键值对
26     $redis->hget($key, 'field2');           //获取hash其中的一个键值
27     $redis->hmget($key, array('field2', 'field1'));    //获取hash的多个键值
28     $redis->hgetall($key);  //获取hash中所有的键值对
29     $redis->hlen($key);     //获取hash中键值对的个数
30     $redis->hkeys($key);   //获取hash中所有的键
31     $redis->hvals($key);    //获取hash中所有的值
32     $redis->del($key);  //删除key值
33 
34     //redis list 列表
35     $index = $start = 0;
36     $redis->lpush($key, 'val1', 'val2');    //在list的开头添加多个值
37     $redis->lpop($key); //移除并获取list的第一个元素
38     $redis->rpop($key); //移除并获取list的最后一个元素
39     $stop = $redis->llen($key) - 1; //获取list的长度
40     $redis->lindex($key, $index);   //通过索引获取list元素
41     $redis->lrange($key, $start, $stop);    //获取指定范围内的元素
42 
43     $redis->del($key);
44 
45     //redis set 无序集合
46     $redis->sadd($key, 'val1', 'val2'); //向集合中添加多个元素
47     $redis->scard($key);    //获取集合元素个数
48     $redis->spop($key); //移除并获取集合内随机一个元素
49     $redis->srem($key, 'val1', 'val2'); //移除集合的多个元素
50     $redis->sismember($key, 'val1');    //判断元素是否存在于集合内
51 
52     $redis->del($key);
53     //redis sorted set 有序集合
54     //有序集合里的元素都和一个分数score关联,就靠这个分数score对元素进行排序
55     $redis->zadd($key, $score1, $val1, $score2, $val2); //向集合内添加多个元素
56     $redis->zcard($key);    //获取集合内元素总数
57     $redis->zcount($key, $minScore, $maxScore); //获取集合内分类范围内的元素
58     $redis->zrem($key, $member1, $member2); //移除集合内多个元素
复制代码

 

附:Redis类的源码

   1 <?php
   2 /**
   3  * Helper autocomplete for php redis extension
   4  * @author Max Kamashev <max.kamashev@gmail.com>
   5  * @link https://github.com/ukko/phpredis-phpdoc
   6  *
   7  * @method echo string $string Sends a string to Redis, which replies with the same string
   8  *
   9  * @method  eval( $script, $args = array(), $numKeys = 0 )
  10  *  Evaluate a LUA script serverside
  11  *  @param  string  $script
  12  *  @param  array   $args
  13  *  @param  int     $numKeys
  14  *  @return Mixed.  What is returned depends on what the LUA script itself returns, which could be a scalar value
  15  *  (int/string), or an array. Arrays that are returned can also contain other arrays, if that's how it was set up in
  16  *  your LUA script.  If there is an error executing the LUA script, the getLastError() function can tell you the
  17  *  message that came back from Redis (e.g. compile error).
  18  *  @link   http://redis.io/commands/eval
  19  *  @example
  20  *  <pre>
  21  *  $redis->eval("return 1"); // Returns an integer: 1
  22  *  $redis->eval("return {1,2,3}"); // Returns Array(1,2,3)
  23  *  $redis->del('mylist');
  24  *  $redis->rpush('mylist','a');
  25  *  $redis->rpush('mylist','b');
  26  *  $redis->rpush('mylist','c');
  27  *  // Nested response:  Array(1,2,3,Array('a','b','c'));
  28  *  $redis->eval("return {1,2,3,redis.call('lrange','mylist',0,-1)}}");
  29  * </pre>
  30  *
  31  */
  32 class Redis
  33 {
  34     const AFTER                 = 'after';
  35     const BEFORE                = 'before';
  36 
  37     /**
  38      * Options
  39      */
  40     const OPT_SERIALIZER        = 1;
  41     const OPT_PREFIX            = 2;
  42     const OPT_READ_TIMEOUT = 3;
  43     const OPT_SCAN = 4;
  44 
  45     /**
  46      * Serializers
  47      */
  48     const SERIALIZER_NONE       = 0;
  49     const SERIALIZER_PHP        = 1;
  50     const SERIALIZER_IGBINARY   = 2;
  51 
  52     /**
  53      * Multi
  54      */
  55     const ATOMIC = 0;
  56     const MULTI = 1;
  57     const PIPELINE = 2;
  58 
  59     /**
  60      * Type
  61      */
  62     const REDIS_NOT_FOUND       = 0;
  63     const REDIS_STRING          = 1;
  64     const REDIS_SET             = 2;
  65     const REDIS_LIST            = 3;
  66     const REDIS_ZSET            = 4;
  67     const REDIS_HASH            = 5;
  68 
  69 
  70     /**
  71      * Scan
  72      */
  73      const SCAN_NORETRY = 0;
  74      const SCAN_RETRY = 1;
  75 
  76      /**
  77      * Creates a Redis client
  78      *
  79      * @example $redis = new Redis();
  80      */
  81     public function __construct( ) {}
  82 
  83     /**
  84      * Connects to a Redis instance.
  85      *
  86      * @param string    $host       can be a host, or the path to a unix domain socket
  87      * @param int       $port       optional
  88      * @param float     $timeout    value in seconds (optional, default is 0.0 meaning unlimited)
  89      * @return bool                 TRUE on success, FALSE on error.
  90      * <pre>
  91      * $redis->connect('127.0.0.1', 6379);
  92      * $redis->connect('127.0.0.1');            // port 6379 by default
  93      * $redis->connect('127.0.0.1', 6379, 2.5); // 2.5 sec timeout.
  94      * $redis->connect('/tmp/redis.sock');      // unix domain socket.
  95      * </pre>
  96      */
  97     public function connect( $host, $port = 6379, $timeout = 0.0 ) {}
  98 
  99     /**
 100      * Set the string value in argument as value of the key, with a time to live.
 101      *
 102      * @param   string $key
 103      * @param   int $ttl in milliseconds
 104      * @param   string $value
 105      * @return  bool:   TRUE if the command is successful.
 106      * @link    http://redis.io/commands/setex
 107      * $redis->psetex('key', 100, 'value'); // sets key → value, with 0.1 sec TTL.
 108      */
 109     public function psetex($key, $ttl, $value) {}
 110 
 111     /**
 112      * Scan a set for members.
 113      *
 114      * @see scan()
 115      * @param   string $key
 116      * @param   int $iterator
 117      * @param   string $pattern
 118      * @param   int $count
 119      * @return  array|bool
 120      */
 121     public function sScan($key, $iterator, $pattern = '', $count = 0) {}
 122 
 123     /**
 124      * Scan the keyspace for keys.
 125      *
 126      * @param   int $iterator
 127      * @param   string $pattern
 128      * @param   int $count How many keys to return in a go (only a sugestion to Redis)
 129      * @return  array|bool   an array of keys or FALSE if there are no more keys
 130      * @link    http://redis.io/commands/scan
 131      * <pre>
 132      * $it = NULL; // Initialize our iterator to NULL
 133      * $redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY); // retry when we get no keys back
 134      * while($arr_keys = $redis->scan($it)) {
 135      *   foreach($arr_keys as $str_key) {
 136      *     echo "Here is a key: $str_key\n";
 137      *   }
 138      *   echo "No more keys to scan!\n";
 139      * }
 140      * </pre>
 141      */
 142     public function scan($iterator, $pattern = '', $count = 0) {}
 143 
 144     /**
 145      * Scan a sorted set for members, with optional pattern and count.
 146      *
 147      * @see scan()
 148      * @param   string  $key
 149      * @param   int $iterator
 150      * @param   string  $pattern
 151      * @param   int $count
 152      * @return  array|bool
 153      */
 154     public function zScan($key, $iterator, $pattern = '', $count = 0) {}
 155 
 156     /**
 157      * Scan a HASH value for members, with an optional pattern and count.
 158      *
 159      * @see scan()
 160      * @param   string $key
 161      * @param   int $iterator
 162      * @param   string $pattern
 163      * @param   int $count
 164      * @return  array
 165      */
 166     public function hScan($key, $iterator, $pattern = '', $count = 0) {}
 167 
 168 
 169 
 170     /**
 171      * Issue the CLIENT command with various arguments.
 172      * @param   string $command list | getname | setname | kill
 173      * @param   string $arg
 174      * @return  mixed
 175      * @link    http://redis.io/commands/client-list
 176      * @link    http://redis.io/commands/client-getname
 177      * @link    http://redis.io/commands/client-setname
 178      * @link    http://redis.io/commands/client-kill
 179      * <pre>
 180      * $redis->client('list');
 181      * $redis->client('getname');
 182      * $redis->client('setname', 'somename');
 183      * $redis->client('kill', <ip:port>);
 184      * </pre>
 185      *
 186      *
 187      * CLIENT LIST will return an array of arrays with client information.
 188      * CLIENT GETNAME will return the client name or false if none has been set
 189      * CLIENT SETNAME will return true if it can be set and false if not
 190      * CLIENT KILL will return true if the client can be killed, and false if not
 191      */
 192     public function client($command, $arg = '') {}
 193 
 194     /**
 195      * Access the Redis slow log.
 196      *
 197      * @param   string $command get | len | reset
 198      * @return  mixed
 199      * @link    http://redis.io/commands/slowlog
 200      * <pre>
 201      * // Get ten slowlog entries
 202      * $redis->slowlog('get', 10);
 203      *
 204      * // Get the default number of slowlog entries
 205      * $redis->slowlog('get');
 206      *
 207      * // Reset our slowlog
 208      * $redis->slowlog('reset');
 209      *
 210      * // Retrieve slowlog length
 211      * $redis->slowlog('len');
 212      * </pre>
 213      */
 214     public function slowlog($command) {}
 215 
 216     /**
 217      * @see connect()
 218      * @param string    $host
 219      * @param int       $port
 220      * @param float     $timeout
 221      */
 222     public function open( $host, $port = 6379, $timeout = 0.0 ) {}
 223 
 224     /**
 225      * Connects to a Redis instance or reuse a connection already established with pconnect/popen.
 226      *
 227      * The connection will not be closed on close or end of request until the php process ends.
 228      * So be patient on to many open FD's (specially on redis server side) when using persistent connections on
 229      * many servers connecting to one redis server.
 230      *
 231      * Also more than one persistent connection can be made identified by either host + port + timeout
 232      * or unix socket + timeout.
 233      *
 234      * This feature is not available in threaded versions. pconnect and popen then working like their non persistent
 235      * equivalents.
 236      *
 237      * @param string    $host       can be a host, or the path to a unix domain socket
 238      * @param int       $port       optional
 239      * @param float     $timeout    value in seconds (optional, default is 0 meaning unlimited)
 240      * @return bool                 TRUE on success, FALSE on ertcnror.
 241      * <pre>
 242      * $redis->connect('127.0.0.1', 6379);
 243      * $redis->connect('127.0.0.1');            // port 6379 by default
 244      * $redis->connect('127.0.0.1', 6379, 2.5); // 2.5 sec timeout.
 245      * $redis->connect('/tmp/redis.sock');      // unix domain socket.
 246      * </pre>
 247      */
 248     public function pconnect( $host, $port = 6379, $timeout = 0.0 ) {}
 249 
 250     /**
 251      * @see pconnect()
 252      * @param string    $host
 253      * @param int       $port
 254      * @param float     $timeout
 255      */
 256     public function popen( $host, $port = 6379, $timeout = 0.0 ) {}
 257 
 258     /**
 259      * Disconnects from the Redis instance, except when pconnect is used.
 260      */
 261     public function close( ) {}
 262 
 263     /**
 264      * Set client option.
 265      *
 266      * @param   string  $name    parameter name
 267      * @param   string  $value   parameter value
 268      * @return  bool:   TRUE on success, FALSE on error.
 269      * @example
 270      * <pre>
 271      * $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE);        // don't serialize data
 272      * $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP);         // use built-in serialize/unserialize
 273      * $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_IGBINARY);    // use igBinary serialize/unserialize
 274      * $redis->setOption(Redis::OPT_PREFIX, 'myAppName:');                      // use custom prefix on all keys
 275      * </pre>
 276      */
 277     public function setOption( $name, $value ) {}
 278 
 279     /**
 280      * Get client option
 281      *
 282      * @param   string  $name parameter name
 283      * @return  int     Parameter value.
 284      * @example
 285      * // return Redis::SERIALIZER_NONE, Redis::SERIALIZER_PHP, or Redis::SERIALIZER_IGBINARY.
 286      * $redis->getOption(Redis::OPT_SERIALIZER);
 287      */
 288     public function getOption( $name ) {}
 289 
 290     /**
 291      * Check the current connection status
 292      *
 293      * @return  string STRING: +PONG on success. Throws a RedisException object on connectivity error, as described above.
 294      * @link    http://redis.io/commands/ping
 295      */
 296     public function ping( ) {}
 297 
 298     /**
 299      * Get the value related to the specified key
 300      *
 301      * @param   string  $key
 302      * @return  string|bool: If key didn't exist, FALSE is returned. Otherwise, the value related to this key is returned.
 303      * @link    http://redis.io/commands/get
 304      * @example $redis->get('key');
 305      */
 306     public function get( $key ) {}
 307 
 308 
 309     /**
 310      * Set the string value in argument as value of the key.
 311      *
 312      * @param   string  $key
 313      * @param   string  $value
 314      * @param   int   $timeout [optional] Calling setex() is preferred if you want a timeout.
 315      * @return  bool:   TRUE if the command is successful.
 316      * @link    http://redis.io/commands/set
 317      * @example $redis->set('key', 'value');
 318      */
 319     public function set( $key, $value, $timeout = 0 ) {}
 320 
 321     /**
 322      * Set the string value in argument as value of the key, with a time to live.
 323      *
 324      * @param   string  $key
 325      * @param   int     $ttl
 326      * @param   string  $value
 327      * @return  bool:   TRUE if the command is successful.
 328      * @link    http://redis.io/commands/setex
 329      * @example $redis->setex('key', 3600, 'value'); // sets key → value, with 1h TTL.
 330      */
 331     public function setex( $key, $ttl, $value ) {}
 332 
 333     /**
 334      * Set the string value in argument as value of the key if the key doesn't already exist in the database.
 335      *
 336      * @param   string  $key
 337      * @param   string  $value
 338      * @return  bool:   TRUE in case of success, FALSE in case of failure.
 339      * @link    http://redis.io/commands/setnx
 340      * @example
 341      * <pre>
 342      * $redis->setnx('key', 'value');   // return TRUE
 343      * $redis->setnx('key', 'value');   // return FALSE
 344      * </pre>
 345      */
 346     public function setnx( $key, $value ) {}
 347 
 348     /**
 349      * Remove specified keys.
 350      *
 351      * @param   int|array   $key1 An array of keys, or an undefined number of parameters, each a key: key1 key2 key3 ... keyN
 352      * @param   string      $key2 ...
 353      * @param   string      $key3 ...
 354      * @return int Number of keys deleted.
 355      * @link    http://redis.io/commands/del
 356      * @example
 357      * <pre>
 358      * $redis->set('key1', 'val1');
 359      * $redis->set('key2', 'val2');
 360      * $redis->set('key3', 'val3');
 361      * $redis->set('key4', 'val4');
 362      * $redis->delete('key1', 'key2');          // return 2
 363      * $redis->delete(array('key3', 'key4'));   // return 2
 364      * </pre>
 365      */
 366     public function del( $key1, $key2 = null, $key3 = null ) {}
 367 
 368     /**
 369      * @see del()
 370      * @param $key1
 371      * @param null $key2
 372      * @param null $key3
 373      */
 374     public function delete( $key1, $key2 = null, $key3 = null ) {}
 375 
 376     /**
 377      * Enter and exit transactional mode.
 378      *
 379      * @internal param Redis::MULTI|Redis::PIPELINE
 380      * Defaults to Redis::MULTI.
 381      * A Redis::MULTI block of commands runs as a single transaction;
 382      * a Redis::PIPELINE block is simply transmitted faster to the server, but without any guarantee of atomicity.
 383      * discard cancels a transaction.
 384      * @return Redis returns the Redis instance and enters multi-mode.
 385      * Once in multi-mode, all subsequent method calls return the same object until exec() is called.
 386      * @link    http://redis.io/commands/multi
 387      * @example
 388      * <pre>
 389      * $ret = $redis->multi()
 390      *      ->set('key1', 'val1')
 391      *      ->get('key1')
 392      *      ->set('key2', 'val2')
 393      *      ->get('key2')
 394      *      ->exec();
 395      *
 396      * //$ret == array (
 397      * //    0 => TRUE,
 398      * //    1 => 'val1',
 399      * //    2 => TRUE,
 400      * //    3 => 'val2');
 401      * </pre>
 402      */
 403     public function multi( ) {}
 404 
 405     /**
 406      * @see multi()
 407      * @link    http://redis.io/commands/exec
 408      */
 409     public function exec( ) {}
 410 
 411     /**
 412      * @see multi()
 413      * @link    http://redis.io/commands/discard
 414      */
 415     public function discard( ) {}
 416 
 417     /**
 418      * Watches a key for modifications by another client. If the key is modified between WATCH and EXEC,
 419      * the MULTI/EXEC transaction will fail (return FALSE). unwatch cancels all the watching of all keys by this client.
 420      * @param string | array $key: a list of keys
 421      * @return void
 422      * @link    http://redis.io/commands/watch
 423      * @example
 424      * <pre>
 425      * $redis->watch('x');
 426      * // long code here during the execution of which other clients could well modify `x`
 427      * $ret = $redis->multi()
 428      *          ->incr('x')
 429      *          ->exec();
 430      * // $ret = FALSE if x has been modified between the call to WATCH and the call to EXEC.
 431      * </pre>
 432      */
 433     public function watch( $key ) {}
 434 
 435     /**
 436      * @see watch()
 437      * @link    http://redis.io/commands/unwatch
 438      */
 439     public function unwatch( ) {}
 440 
 441     /**
 442      * Subscribe to channels. Warning: this function will probably change in the future.
 443      *
 444      * @param array             $channels an array of channels to subscribe to
 445      * @param string | array    $callback either a string or an array($instance, 'method_name').
 446      * The callback function receives 3 parameters: the redis instance, the channel name, and the message.
 447      * @link    http://redis.io/commands/subscribe
 448      * @example
 449      * <pre>
 450      * function f($redis, $chan, $msg) {
 451      *  switch($chan) {
 452      *      case 'chan-1':
 453      *          ...
 454      *          break;
 455      *
 456      *      case 'chan-2':
 457      *                     ...
 458      *          break;
 459      *
 460      *      case 'chan-2':
 461      *          ...
 462      *          break;
 463      *      }
 464      * }
 465      *
 466      * $redis->subscribe(array('chan-1', 'chan-2', 'chan-3'), 'f'); // subscribe to 3 chans
 467      * </pre>
 468      */
 469     public function subscribe( $channels, $callback ) {}
 470 
 471     /**
 472      * Subscribe to channels by pattern
 473      *
 474      * @param   array           $patterns   The number of elements removed from the set.
 475      * @param   string|array    $callback   Either a string or an array with an object and method.
 476      *                          The callback will get four arguments ($redis, $pattern, $channel, $message)
 477      * @link    http://redis.io/commands/psubscribe
 478      * @example
 479      * <pre>
 480      * function psubscribe($redis, $pattern, $chan, $msg) {
 481      *  echo "Pattern: $pattern\n";
 482      *  echo "Channel: $chan\n";
 483      *  echo "Payload: $msg\n";
 484      * }
 485      * </pre>
 486      */
 487     public function psubscribe( $patterns, $callback ) {}
 488 
 489     /**
 490      * Publish messages to channels. Warning: this function will probably change in the future.
 491      *
 492      * @param   string $channel a channel to publish to
 493      * @param   string $message string
 494      * @link    http://redis.io/commands/publish
 495      * @return  int Number of clients that received the message
 496      * @example $redis->publish('chan-1', 'hello, world!'); // send message.
 497      */
 498     public function publish( $channel, $message ) {}
 499 
 500     /**
 501      * Verify if the specified key exists.
 502      *
 503      * @param   string $key
 504      * @return  bool: If the key exists, return TRUE, otherwise return FALSE.
 505      * @link    http://redis.io/commands/exists
 506      * @example
 507      * <pre>
 508      * $redis->set('key', 'value');
 509      * $redis->exists('key');               //  TRUE
 510      * $redis->exists('NonExistingKey');    // FALSE
 511      * </pre>
 512      */
 513     public function exists( $key ) {}
 514 
 515     /**
 516      * Increment the number stored at key by one.
 517      *
 518      * @param   string $key
 519      * @return  int    the new value
 520      * @link    http://redis.io/commands/incr
 521      * @example
 522      * <pre>
 523      * $redis->incr('key1'); // key1 didn't exists, set to 0 before the increment and now has the value 1
 524      * $redis->incr('key1'); // 2
 525      * $redis->incr('key1'); // 3
 526      * $redis->incr('key1'); // 4
 527      * </pre>
 528      */
 529     public function incr( $key ) {}
 530 
 531     /**
 532      * Increment the float value of a key by the given amount
 533      *
 534      * @param   string  $key
 535      * @param   float   $increment
 536      * @return  float
 537      * @link    http://redis.io/commands/incrbyfloat
 538      * @example
 539      * <pre>
 540      * $redis = new Redis();
 541      * $redis->connect('127.0.0.1');
 542      * $redis->set('x', 3);
 543      * var_dump( $redis->incrByFloat('x', 1.5) );   // float(4.5)
 544      *
 545      * // ! SIC
 546      * var_dump( $redis->get('x') );                // string(3) "4.5"
 547      * </pre>
 548      */
 549     public function incrByFloat( $key, $increment ) {}
 550 
 551     /**
 552      * Increment the number stored at key by one. If the second argument is filled, it will be used as the integer
 553      * value of the increment.
 554      *
 555      * @param   string    $key    key
 556      * @param   int       $value  value that will be added to key (only for incrBy)
 557      * @return  int         the new value
 558      * @link    http://redis.io/commands/incrby
 559      * @example
 560      * <pre>
 561      * $redis->incr('key1');        // key1 didn't exists, set to 0 before the increment and now has the value 1
 562      * $redis->incr('key1');        // 2
 563      * $redis->incr('key1');        // 3
 564      * $redis->incr('key1');        // 4
 565      * $redis->incrBy('key1', 10);  // 14
 566      * </pre>
 567      */
 568     public function incrBy( $key, $value ) {}
 569 
 570     /**
 571      * Decrement the number stored at key by one.
 572      *
 573      * @param   string $key
 574      * @return  int    the new value
 575      * @link    http://redis.io/commands/decr
 576      * @example
 577      * <pre>
 578      * $redis->decr('key1'); // key1 didn't exists, set to 0 before the increment and now has the value -1
 579      * $redis->decr('key1'); // -2
 580      * $redis->decr('key1'); // -3
 581      * </pre>
 582      */
 583     public function decr( $key ) {}
 584 
 585     /**
 586      * Decrement the number stored at key by one. If the second argument is filled, it will be used as the integer
 587      * value of the decrement.
 588      *
 589      * @param   string    $key
 590      * @param   int       $value  that will be substracted to key (only for decrBy)
 591      * @return  int       the new value
 592      * @link    http://redis.io/commands/decrby
 593      * @example
 594      * <pre>
 595      * $redis->decr('key1');        // key1 didn't exists, set to 0 before the increment and now has the value -1
 596      * $redis->decr('key1');        // -2
 597      * $redis->decr('key1');        // -3
 598      * $redis->decrBy('key1', 10);  // -13
 599      * </pre>
 600      */
 601     public function decrBy( $key, $value ) {}
 602 
 603     /**
 604      * Get the values of all the specified keys. If one or more keys dont exist, the array will contain FALSE at the
 605      * position of the key.
 606      *
 607      * @param   array $keys Array containing the list of the keys
 608      * @return  array Array containing the values related to keys in argument
 609      * @example
 610      * <pre>
 611      * $redis->set('key1', 'value1');
 612      * $redis->set('key2', 'value2');
 613      * $redis->set('key3', 'value3');
 614      * $redis->getMultiple(array('key1', 'key2', 'key3')); // array('value1', 'value2', 'value3');
 615      * $redis->getMultiple(array('key0', 'key1', 'key5')); // array(`FALSE`, 'value2', `FALSE`);
 616      * </pre>
 617      */
 618     public function getMultiple( array $keys ) {}
 619 
 620     /**
 621      * Adds the string values to the head (left) of the list. Creates the list if the key didn't exist.
 622      * If the key exists and is not a list, FALSE is returned.
 623      *
 624      * @param   string $key
 625      * @param   string $value1  String, value to push in key
 626      * @param   string $value2  Optional
 627      * @param   string $valueN  Optional
 628      * @return  int    The new length of the list in case of success, FALSE in case of Failure.
 629      * @link    http://redis.io/commands/lpush
 630      * @example
 631      * <pre>
 632      * $redis->lPush('l', 'v1', 'v2', 'v3', 'v4')   // int(4)
 633      * var_dump( $redis->lRange('l', 0, -1) );
 634      * //// Output:
 635      * // array(4) {
 636      * //   [0]=> string(2) "v4"
 637      * //   [1]=> string(2) "v3"
 638      * //   [2]=> string(2) "v2"
 639      * //   [3]=> string(2) "v1"
 640      * // }
 641      * </pre>
 642      */
 643     public function lPush( $key, $value1, $value2 = null, $valueN = null ) {}
 644 
 645     /**
 646      * Adds the string values to the tail (right) of the list. Creates the list if the key didn't exist.
 647      * If the key exists and is not a list, FALSE is returned.
 648      *
 649      * @param   string  $key
 650      * @param   string  $value1 String, value to push in key
 651      * @param   string  $value2 Optional
 652      * @param   string  $valueN Optional
 653      * @return  int     The new length of the list in case of success, FALSE in case of Failure.
 654      * @link    http://redis.io/commands/rpush
 655      * @example
 656      * <pre>
 657      * $redis->rPush('l', 'v1', 'v2', 'v3', 'v4');    // int(4)
 658      * var_dump( $redis->lRange('l', 0, -1) );
 659      * //// Output:
 660      * // array(4) {
 661      * //   [0]=> string(2) "v1"
 662      * //   [1]=> string(2) "v2"
 663      * //   [2]=> string(2) "v3"
 664      * //   [3]=> string(2) "v4"
 665      * // }
 666      * </pre>
 667      */
 668     public function rPush( $key, $value1, $value2 = null, $valueN = null ) {}
 669 
 670     /**
 671      * Adds the string value to the head (left) of the list if the list exists.
 672      *
 673      * @param   string  $key
 674      * @param   string  $value String, value to push in key
 675      * @return  int     The new length of the list in case of success, FALSE in case of Failure.
 676      * @link    http://redis.io/commands/lpushx
 677      * @example
 678      * <pre>
 679      * $redis->delete('key1');
 680      * $redis->lPushx('key1', 'A');     // returns 0
 681      * $redis->lPush('key1', 'A');      // returns 1
 682      * $redis->lPushx('key1', 'B');     // returns 2
 683      * $redis->lPushx('key1', 'C');     // returns 3
 684      * // key1 now points to the following list: [ 'A', 'B', 'C' ]
 685      * </pre>
 686      */
 687     public function lPushx( $key, $value ) {}
 688 
 689     /**
 690      * Adds the string value to the tail (right) of the list if the ist exists. FALSE in case of Failure.
 691      *
 692      * @param   string  $key
 693      * @param   string  $value String, value to push in key
 694      * @return  int     The new length of the list in case of success, FALSE in case of Failure.
 695      * @link    http://redis.io/commands/rpushx
 696      * @example
 697      * <pre>
 698      * $redis->delete('key1');
 699      * $redis->rPushx('key1', 'A'); // returns 0
 700      * $redis->rPush('key1', 'A'); // returns 1
 701      * $redis->rPushx('key1', 'B'); // returns 2
 702      * $redis->rPushx('key1', 'C'); // returns 3
 703      * // key1 now points to the following list: [ 'A', 'B', 'C' ]
 704      * </pre>
 705      */
 706     public function rPushx( $key, $value ) {}
 707 
 708     /**
 709      * Returns and removes the first element of the list.
 710      *
 711      * @param   string $key
 712      * @return  string if command executed successfully BOOL FALSE in case of failure (empty list)
 713      * @link    http://redis.io/commands/lpop
 714      * @example
 715      * <pre>
 716      * $redis->rPush('key1', 'A');
 717      * $redis->rPush('key1', 'B');
 718      * $redis->rPush('key1', 'C');  // key1 => [ 'A', 'B', 'C' ]
 719      * $redis->lPop('key1');        // key1 => [ 'B', 'C' ]
 720      * </pre>
 721      */
 722     public function lPop( $key ) {}
 723 
 724     /**
 725      * Returns and removes the last element of the list.
 726      *
 727      * @param   string $key
 728      * @return  string if command executed successfully BOOL FALSE in case of failure (empty list)
 729      * @link    http://redis.io/commands/rpop
 730      * @example
 731      * <pre>
 732      * $redis->rPush('key1', 'A');
 733      * $redis->rPush('key1', 'B');
 734      * $redis->rPush('key1', 'C');  // key1 => [ 'A', 'B', 'C' ]
 735      * $redis->rPop('key1');        // key1 => [ 'A', 'B' ]
 736      * </pre>
 737      */
 738     public function rPop( $key ) {}
 739 
 740     /**
 741      * Is a blocking lPop primitive. If at least one of the lists contains at least one element,
 742      * the element will be popped from the head of the list and returned to the caller.
 743      * Il all the list identified by the keys passed in arguments are empty, blPop will block
 744      * during the specified timeout until an element is pushed to one of those lists. This element will be popped.
 745      *
 746      * @param   array $keys Array containing the keys of the lists INTEGER Timeout
 747      * Or STRING Key1 STRING Key2 STRING Key3 ... STRING Keyn INTEGER Timeout
 748      * @return  array array('listName', 'element')
 749      * @link    http://redis.io/commands/blpop
 750      * @example
 751      * <pre>
 752      * // Non blocking feature
 753      * $redis->lPush('key1', 'A');
 754      * $redis->delete('key2');
 755      *
 756      * $redis->blPop('key1', 'key2', 10); // array('key1', 'A')
 757      * // OR
 758      * $redis->blPop(array('key1', 'key2'), 10); // array('key1', 'A')
 759      *
 760      * $redis->brPop('key1', 'key2', 10); // array('key1', 'A')
 761      * // OR
 762      * $redis->brPop(array('key1', 'key2'), 10); // array('key1', 'A')
 763      *
 764      * // Blocking feature
 765      *
 766      * // process 1
 767      * $redis->delete('key1');
 768      * $redis->blPop('key1', 10);
 769      * // blocking for 10 seconds
 770      *
 771      * // process 2
 772      * $redis->lPush('key1', 'A');
 773      *
 774      * // process 1
 775      * // array('key1', 'A') is returned
 776      * </pre>
 777      */
 778     public function blPop( array $keys ) {}
 779 
 780     /**
 781      * Is a blocking rPop primitive. If at least one of the lists contains at least one element,
 782      * the element will be popped from the head of the list and returned to the caller.
 783      * Il all the list identified by the keys passed in arguments are empty, brPop will
 784      * block during the specified timeout until an element is pushed to one of those lists. T
 785      * his element will be popped.
 786      *
 787      * @param   array $keys Array containing the keys of the lists INTEGER Timeout
 788      * Or STRING Key1 STRING Key2 STRING Key3 ... STRING Keyn INTEGER Timeout
 789      * @return  array array('listName', 'element')
 790      * @link    http://redis.io/commands/brpop
 791      * @example
 792      * <pre>
 793      * // Non blocking feature
 794      * $redis->lPush('key1', 'A');
 795      * $redis->delete('key2');
 796      *
 797      * $redis->blPop('key1', 'key2', 10); // array('key1', 'A')
 798      * // OR
 799      * $redis->blPop(array('key1', 'key2'), 10); // array('key1', 'A')
 800      *
 801      * $redis->brPop('key1', 'key2', 10); // array('key1', 'A')
 802      * // OR
 803      * $redis->brPop(array('key1', 'key2'), 10); // array('key1', 'A')
 804      *
 805      * // Blocking feature
 806      *
 807      * // process 1
 808      * $redis->delete('key1');
 809      * $redis->blPop('key1', 10);
 810      * // blocking for 10 seconds
 811      *
 812      * // process 2
 813      * $redis->lPush('key1', 'A');
 814      *
 815      * // process 1
 816      * // array('key1', 'A') is returned
 817      * </pre>
 818      */
 819     public function brPop( array $keys ) {}
 820 
 821 
 822     /**
 823      * Returns the size of a list identified by Key. If the list didn't exist or is empty,
 824      * the command returns 0. If the data type identified by Key is not a list, the command return FALSE.
 825      *
 826      * @param   string  $key
 827      * @return  int     The size of the list identified by Key exists.
 828      * bool FALSE if the data type identified by Key is not list
 829      * @link    http://redis.io/commands/llen
 830      * @example
 831      * <pre>
 832      * $redis->rPush('key1', 'A');
 833      * $redis->rPush('key1', 'B');
 834      * $redis->rPush('key1', 'C');  // key1 => [ 'A', 'B', 'C' ]
 835      * $redis->lLen('key1');       // 3
 836      * $redis->rPop('key1');
 837      * $redis->lLen('key1');       // 2
 838      * </pre>
 839      */
 840     public function lLen( $key ) {}
 841 
 842     /**
 843      * @see     lLen()
 844      * @param   string    $key
 845      * @param   int       $index
 846      * @link    http://redis.io/commands/llen
 847      */
 848     public function lSize( $key ) {}
 849 
 850 
 851     /**
 852      * Return the specified element of the list stored at the specified key.
 853      * 0 the first element, 1 the second ... -1 the last element, -2 the penultimate ...
 854      * Return FALSE in case of a bad index or a key that doesn't point to a list.
 855      * @param string    $key
 856      * @param int       $index
 857      * @return String the element at this index
 858      * Bool FALSE if the key identifies a non-string data type, or no value corresponds to this index in the list Key.
 859      * @link    http://redis.io/commands/lindex
 860      * @example
 861      * <pre>
 862      * $redis->rPush('key1', 'A');
 863      * $redis->rPush('key1', 'B');
 864      * $redis->rPush('key1', 'C');  // key1 => [ 'A', 'B', 'C' ]
 865      * $redis->lGet('key1', 0);     // 'A'
 866      * $redis->lGet('key1', -1);    // 'C'
 867      * $redis->lGet('key1', 10);    // `FALSE`
 868      * </pre>
 869      */
 870     public function lIndex( $key, $index ) {}
 871 
 872     /**
 873      * @see lIndex()
 874      * @param   string    $key
 875      * @param   int       $index
 876      * @link    http://redis.io/commands/lindex
 877      */
 878     public function lGet( $key, $index ) {}
 879 
 880 
 881     /**
 882      * Set the list at index with the new value.
 883      *
 884      * @param string    $key
 885      * @param int       $index
 886      * @param string    $value
 887      * @return BOOL TRUE if the new value is setted. FALSE if the index is out of range, or data type identified by key
 888      * is not a list.
 889      * @link    http://redis.io/commands/lset
 890      * @example
 891      * <pre>
 892      * $redis->rPush('key1', 'A');
 893      * $redis->rPush('key1', 'B');
 894      * $redis->rPush('key1', 'C');  // key1 => [ 'A', 'B', 'C' ]
 895      * $redis->lGet('key1', 0);     // 'A'
 896      * $redis->lSet('key1', 0, 'X');
 897      * $redis->lGet('key1', 0);     // 'X'
 898      * </pre>
 899      */
 900     public function lSet( $key, $index, $value ) {}
 901 
 902 
 903     /**
 904      * Returns the specified elements of the list stored at the specified key in
 905      * the range [start, end]. start and stop are interpretated as indices: 0 the first element,
 906      * 1 the second ... -1 the last element, -2 the penultimate ...
 907      * @param   string  $key
 908      * @param   int     $start
 909      * @param   int     $end
 910      * @return  array containing the values in specified range.
 911      * @link    http://redis.io/commands/lrange
 912      * @example
 913      * <pre>
 914      * $redis->rPush('key1', 'A');
 915      * $redis->rPush('key1', 'B');
 916      * $redis->rPush('key1', 'C');
 917      * $redis->lRange('key1', 0, -1); // array('A', 'B', 'C')
 918      * </pre>
 919      */
 920     public function lRange( $key, $start, $end ) {}
 921 
 922     /**
 923      * @see lRange()
 924      * @link http://redis.io/commands/lrange
 925      * @param string    $key
 926      * @param int       $start
 927      * @param int       $end
 928      */
 929     public function lGetRange( $key, $start, $end ) {}
 930 
 931 
 932     /**
 933      * Trims an existing list so that it will contain only a specified range of elements.
 934      *
 935      * @param string    $key
 936      * @param int       $start
 937      * @param int       $stop
 938      * @return array    Bool return FALSE if the key identify a non-list value.
 939      * @link        http://redis.io/commands/ltrim
 940      * @example
 941      * <pre>
 942      * $redis->rPush('key1', 'A');
 943      * $redis->rPush('key1', 'B');
 944      * $redis->rPush('key1', 'C');
 945      * $redis->lRange('key1', 0, -1); // array('A', 'B', 'C')
 946      * $redis->lTrim('key1', 0, 1);
 947      * $redis->lRange('key1', 0, -1); // array('A', 'B')
 948      * </pre>
 949      */
 950     public function lTrim( $key, $start, $stop ) {}
 951 
 952     /**
 953      * @see lTrim()
 954      * @link  http://redis.io/commands/ltrim
 955      * @param string    $key
 956      * @param int       $start
 957      * @param int       $stop
 958      */
 959     public function listTrim( $key, $start, $stop ) {}
 960 
 961 
 962     /**
 963      * Removes the first count occurences of the value element from the list.
 964      * If count is zero, all the matching elements are removed. If count is negative,
 965      * elements are removed from tail to head.
 966      *
 967      * @param   string  $key
 968      * @param   string  $value
 969      * @param   int     $count
 970      * @return  int     the number of elements to remove
 971      * bool FALSE if the value identified by key is not a list.
 972      * @link    http://redis.io/commands/lrem
 973      * @example
 974      * <pre>
 975      * $redis->lPush('key1', 'A');
 976      * $redis->lPush('key1', 'B');
 977      * $redis->lPush('key1', 'C');
 978      * $redis->lPush('key1', 'A');
 979      * $redis->lPush('key1', 'A');
 980      *
 981      * $redis->lRange('key1', 0, -1);   // array('A', 'A', 'C', 'B', 'A')
 982      * $redis->lRem('key1', 'A', 2);    // 2
 983      * $redis->lRange('key1', 0, -1);   // array('C', 'B', 'A')
 984      * </pre>
 985      */
 986     public function lRem( $key, $value, $count ) {}
 987 
 988     /**
 989      * @see lRem
 990      * @link    http://redis.io/commands/lremove
 991      * @param string    $key
 992      * @param string    $value
 993      * @param int       $count
 994      */
 995     public function lRemove( $key, $value, $count ) {}
 996 
 997 
 998     /**
 999      * Insert value in the list before or after the pivot value. the parameter options
1000      * specify the position of the insert (before or after). If the list didn't exists,
1001      * or the pivot didn't exists, the value is not inserted.
1002      *
1003      * @param   string  $key
1004      * @param   int     $position Redis::BEFORE | Redis::AFTER
1005      * @param   string  $pivot
1006      * @param   string  $value
1007      * @return  int     The number of the elements in the list, -1 if the pivot didn't exists.
1008      * @link    http://redis.io/commands/linsert
1009      * @example
1010      * <pre>
1011      * $redis->delete('key1');
1012      * $redis->lInsert('key1', Redis::AFTER, 'A', 'X');     // 0
1013      *
1014      * $redis->lPush('key1', 'A');
1015      * $redis->lPush('key1', 'B');
1016      * $redis->lPush('key1', 'C');
1017      *
1018      * $redis->lInsert('key1', Redis::BEFORE, 'C', 'X');    // 4
1019      * $redis->lRange('key1', 0, -1);                       // array('A', 'B', 'X', 'C')
1020      *
1021      * $redis->lInsert('key1', Redis::AFTER, 'C', 'Y');     // 5
1022      * $redis->lRange('key1', 0, -1);                       // array('A', 'B', 'X', 'C', 'Y')
1023      *
1024      * $redis->lInsert('key1', Redis::AFTER, 'W', 'value'); // -1
1025      * </pre>
1026      */
1027     public function lInsert( $key, $position, $pivot, $value ) {}
1028 
1029 
1030     /**
1031      * Adds a values to the set value stored at key.
1032      * If this value is already in the set, FALSE is returned.
1033      *
1034      * @param   string  $key        Required key
1035      * @param   string  $value1     Required value
1036      * @param   string  $value2     Optional value
1037      * @param   string  $valueN     Optional value
1038      * @return  int     The number of elements added to the set
1039      * @link    http://redis.io/commands/sadd
1040      * @example
1041      * <pre>
1042      * $redis->sAdd('k', 'v1');                // int(1)
1043      * $redis->sAdd('k', 'v1', 'v2', 'v3');    // int(2)
1044      * </pre>
1045      */
1046     public function sAdd( $key, $value1, $value2 = null, $valueN = null ) {}
1047 
1048 
1049     /**
1050      * Removes the specified members from the set value stored at key.
1051      *
1052      * @param   string  $key
1053      * @param   string  $member1
1054      * @param   string  $member2
1055      * @param   string  $memberN
1056      * @return  int     The number of elements removed from the set.
1057      * @link    http://redis.io/commands/srem
1058      * @example
1059      * <pre>
1060      * var_dump( $redis->sAdd('k', 'v1', 'v2', 'v3') );    // int(3)
1061      * var_dump( $redis->sRem('k', 'v2', 'v3') );          // int(2)
1062      * var_dump( $redis->sMembers('k') );
1063      * //// Output:
1064      * // array(1) {
1065      * //   [0]=> string(2) "v1"
1066      * // }
1067      * </pre>
1068      */
1069     public function sRem( $key, $member1, $member2 = null, $memberN = null ) {}
1070 
1071     /**
1072      * @see sRem()
1073      * @link    http://redis.io/commands/srem
1074      * @param   string  $key
1075      * @param   string  $member1
1076      * @param   string  $member2
1077      * @param   string  $memberN
1078      */
1079     public function sRemove( $key, $member1, $member2 = null, $memberN = null ) {}
1080 
1081 
1082     /**
1083      * Moves the specified member from the set at srcKey to the set at dstKey.
1084      *
1085      * @param   string  $srcKey
1086      * @param   string  $dstKey
1087      * @param   string  $member
1088      * @return  bool    If the operation is successful, return TRUE.
1089      * If the srcKey and/or dstKey didn't exist, and/or the member didn't exist in srcKey, FALSE is returned.
1090      * @link    http://redis.io/commands/smove
1091      * @example
1092      * <pre>
1093      * $redis->sAdd('key1' , 'set11');
1094      * $redis->sAdd('key1' , 'set12');
1095      * $redis->sAdd('key1' , 'set13');          // 'key1' => {'set11', 'set12', 'set13'}
1096      * $redis->sAdd('key2' , 'set21');
1097      * $redis->sAdd('key2' , 'set22');          // 'key2' => {'set21', 'set22'}
1098      * $redis->sMove('key1', 'key2', 'set13');  // 'key1' =>  {'set11', 'set12'}
1099      *                                          // 'key2' =>  {'set21', 'set22', 'set13'}
1100      * </pre>
1101      */
1102     public function sMove( $srcKey, $dstKey, $member ) {}
1103 
1104 
1105     /**
1106      * Checks if value is a member of the set stored at the key key.
1107      *
1108      * @param   string  $key
1109      * @param   string  $value
1110      * @return  bool    TRUE if value is a member of the set at key key, FALSE otherwise.
1111      * @link    http://redis.io/commands/sismember
1112      * @example
1113      * <pre>
1114      * $redis->sAdd('key1' , 'set1');
1115      * $redis->sAdd('key1' , 'set2');
1116      * $redis->sAdd('key1' , 'set3'); // 'key1' => {'set1', 'set2', 'set3'}
1117      *
1118      * $redis->sIsMember('key1', 'set1'); // TRUE
1119      * $redis->sIsMember('key1', 'setX'); // FALSE
1120      * </pre>
1121      */
1122     public function sIsMember( $key, $value ) {}
1123 
1124     /**
1125      * @see sIsMember()
1126      * @link    http://redis.io/commands/sismember
1127      * @param   string  $key
1128      * @param   string  $value
1129      */
1130     public function sContains( $key, $value ) {}
1131 
1132     /**
1133      * Returns the cardinality of the set identified by key.
1134      *
1135      * @param   string  $key
1136      * @return  int     the cardinality of the set identified by key, 0 if the set doesn't exist.
1137      * @link    http://redis.io/commands/scard
1138      * @example
1139      * <pre>
1140      * $redis->sAdd('key1' , 'set1');
1141      * $redis->sAdd('key1' , 'set2');
1142      * $redis->sAdd('key1' , 'set3');   // 'key1' => {'set1', 'set2', 'set3'}
1143      * $redis->sCard('key1');           // 3
1144      * $redis->sCard('keyX');           // 0
1145      * </pre>
1146      */
1147     public function sCard( $key ) {}
1148 
1149 
1150     /**
1151      * Removes and returns a random element from the set value at Key.
1152      *
1153      * @param   string  $key
1154      * @return  string  "popped" value
1155      * bool FALSE if set identified by key is empty or doesn't exist.
1156      * @link    http://redis.io/commands/spop
1157      * @example
1158      * <pre>
1159      * $redis->sAdd('key1' , 'set1');
1160      * $redis->sAdd('key1' , 'set2');
1161      * $redis->sAdd('key1' , 'set3');   // 'key1' => {'set3', 'set1', 'set2'}
1162      * $redis->sPop('key1');            // 'set1', 'key1' => {'set3', 'set2'}
1163      * $redis->sPop('key1');            // 'set3', 'key1' => {'set2'}
1164      * </pre>
1165      */
1166     public function sPop( $key ) {}
1167 
1168 
1169     /**
1170      * Returns a random element from the set value at Key, without removing it.
1171      *
1172      * @param   string  $key
1173      * @return  string  value from the set
1174      * bool FALSE if set identified by key is empty or doesn't exist.
1175      * @link    http://redis.io/commands/srandmember
1176      * @example
1177      * <pre>
1178      * $redis->sAdd('key1' , 'set1');
1179      * $redis->sAdd('key1' , 'set2');
1180      * $redis->sAdd('key1' , 'set3');   // 'key1' => {'set3', 'set1', 'set2'}
1181      * $redis->sRandMember('key1');     // 'set1', 'key1' => {'set3', 'set1', 'set2'}
1182      * $redis->sRandMember('key1');     // 'set3', 'key1' => {'set3', 'set1', 'set2'}
1183      * </pre>
1184      */
1185     public function sRandMember( $key ) {}
1186 
1187     /**
1188      * Returns the members of a set resulting from the intersection of all the sets
1189      * held at the specified keys. If just a single key is specified, then this command
1190      * produces the members of this set. If one of the keys is missing, FALSE is returned.
1191      *
1192      * @param   string  $key1  keys identifying the different sets on which we will apply the intersection.
1193      * @param   string  $key2  ...
1194      * @param   string  $keyN  ...
1195      * @return  array, contain the result of the intersection between those keys.
1196      * If the intersection between the different sets is empty, the return value will be empty array.
1197      * @link    http://redis.io/commands/sinterstore
1198      * @example
1199      * <pre>
1200      * $redis->sAdd('key1', 'val1');
1201      * $redis->sAdd('key1', 'val2');
1202      * $redis->sAdd('key1', 'val3');
1203      * $redis->sAdd('key1', 'val4');
1204      *
1205      * $redis->sAdd('key2', 'val3');
1206      * $redis->sAdd('key2', 'val4');
1207      *
1208      * $redis->sAdd('key3', 'val3');
1209      * $redis->sAdd('key3', 'val4');
1210      *
1211      * var_dump($redis->sInter('key1', 'key2', 'key3'));
1212      *
1213      * //array(2) {
1214      * //  [0]=>
1215      * //  string(4) "val4"
1216      * //  [1]=>
1217      * //  string(4) "val3"
1218      * //}
1219      * </pre>
1220      */
1221     public function sInter( $key1, $key2, $keyN = null ) {}
1222 
1223     /**
1224      * Performs a sInter command and stores the result in a new set.
1225      *
1226      * @param   string  $dstKey the key to store the diff into.
1227      * @param   string  $key1 are intersected as in sInter.
1228      * @param   string  $key2 ...
1229      * @param   string  $keyN ...
1230      * @return  int:    The cardinality of the resulting set, or FALSE in case of a missing key.
1231      * @link    http://redis.io/commands/sinterstore
1232      * @example
1233      * <pre>
1234      * $redis->sAdd('key1', 'val1');
1235      * $redis->sAdd('key1', 'val2');
1236      * $redis->sAdd('key1', 'val3');
1237      * $redis->sAdd('key1', 'val4');
1238      *
1239      * $redis->sAdd('key2', 'val3');
1240      * $redis->sAdd('key2', 'val4');
1241      *
1242      * $redis->sAdd('key3', 'val3');
1243      * $redis->sAdd('key3', 'val4');
1244      *
1245      * var_dump($redis->sInterStore('output', 'key1', 'key2', 'key3'));
1246      * var_dump($redis->sMembers('output'));
1247      *
1248      * //int(2)
1249      * //
1250      * //array(2) {
1251      * //  [0]=>
1252      * //  string(4) "val4"
1253      * //  [1]=>
1254      * //  string(4) "val3"
1255      * //}
1256      * </pre>
1257      */
1258     public function sInterStore( $dstKey, $key1, $key2, $keyN = null ) {}
1259 
1260     /**
1261      * Performs the union between N sets and returns it.
1262      *
1263      * @param   string  $key1 Any number of keys corresponding to sets in redis.
1264      * @param   string  $key2 ...
1265      * @param   string  $keyN ...
1266      * @return  array   of strings: The union of all these sets.
1267      * @link    http://redis.io/commands/sunionstore
1268      * @example
1269      * <pre>
1270      * $redis->delete('s0', 's1', 's2');
1271      *
1272      * $redis->sAdd('s0', '1');
1273      * $redis->sAdd('s0', '2');
1274      * $redis->sAdd('s1', '3');
1275      * $redis->sAdd('s1', '1');
1276      * $redis->sAdd('s2', '3');
1277      * $redis->sAdd('s2', '4');
1278      *
1279      * var_dump($redis->sUnion('s0', 's1', 's2'));
1280      *
1281      * array(4) {
1282      * //  [0]=>
1283      * //  string(1) "3"
1284      * //  [1]=>
1285      * //  string(1) "4"
1286      * //  [2]=>
1287      * //  string(1) "1"
1288      * //  [3]=>
1289      * //  string(1) "2"
1290      * //}
1291      * </pre>
1292      */
1293     public function sUnion( $key1, $key2, $keyN = null ) {}
1294 
1295     /**
1296      * Performs the same action as sUnion, but stores the result in the first key
1297      *
1298      * @param   string  $dstKey  the key to store the diff into.
1299      * @param   string  $key1    Any number of keys corresponding to sets in redis.
1300      * @param   string  $key2    ...
1301      * @param   string  $keyN    ...
1302      * @return  int     Any number of keys corresponding to sets in redis.
1303      * @link    http://redis.io/commands/sunionstore
1304      * @example
1305      * <pre>
1306      * $redis->delete('s0', 's1', 's2');
1307      *
1308      * $redis->sAdd('s0', '1');
1309      * $redis->sAdd('s0', '2');
1310      * $redis->sAdd('s1', '3');
1311      * $redis->sAdd('s1', '1');
1312      * $redis->sAdd('s2', '3');
1313      * $redis->sAdd('s2', '4');
1314      *
1315      * var_dump($redis->sUnionStore('dst', 's0', 's1', 's2'));
1316      * var_dump($redis->sMembers('dst'));
1317      *
1318      * //int(4)
1319      * //array(4) {
1320      * //  [0]=>
1321      * //  string(1) "3"
1322      * //  [1]=>
1323      * //  string(1) "4"
1324      * //  [2]=>
1325      * //  string(1) "1"
1326      * //  [3]=>
1327      * //  string(1) "2"
1328      * //}
1329      * </pre>
1330      */
1331     public function sUnionStore( $dstKey, $key1, $key2, $keyN = null ) {}
1332 
1333     /**
1334      * Performs the difference between N sets and returns it.
1335      *
1336      * @param   string  $key1 Any number of keys corresponding to sets in redis.
1337      * @param   string  $key2 ...
1338      * @param   string  $keyN ...
1339      * @return  array   of strings: The difference of the first set will all the others.
1340      * @link    http://redis.io/commands/sdiff
1341      * @example
1342      * <pre>
1343      * $redis->delete('s0', 's1', 's2');
1344      *
1345      * $redis->sAdd('s0', '1');
1346      * $redis->sAdd('s0', '2');
1347      * $redis->sAdd('s0', '3');
1348      * $redis->sAdd('s0', '4');
1349      *
1350      * $redis->sAdd('s1', '1');
1351      * $redis->sAdd('s2', '3');
1352      *
1353      * var_dump($redis->sDiff('s0', 's1', 's2'));
1354      *
1355      * //array(2) {
1356      * //  [0]=>
1357      * //  string(1) "4"
1358      * //  [1]=>
1359      * //  string(1) "2"
1360      * //}
1361      * </pre>
1362      */
1363     public function sDiff( $key1, $key2, $keyN = null ) {}
1364 
1365     /**
1366      * Performs the same action as sDiff, but stores the result in the first key
1367      *
1368      * @param   string  $dstKey    the key to store the diff into.
1369      * @param   string  $key1      Any number of keys corresponding to sets in redis
1370      * @param   string  $key2      ...
1371      * @param   string  $keyN      ...
1372      * @return  int:    The cardinality of the resulting set, or FALSE in case of a missing key.
1373      * @link    http://redis.io/commands/sdiffstore
1374      * @example
1375      * <pre>
1376      * $redis->delete('s0', 's1', 's2');
1377      *
1378      * $redis->sAdd('s0', '1');
1379      * $redis->sAdd('s0', '2');
1380      * $redis->sAdd('s0', '3');
1381      * $redis->sAdd('s0', '4');
1382      *
1383      * $redis->sAdd('s1', '1');
1384      * $redis->sAdd('s2', '3');
1385      *
1386      * var_dump($redis->sDiffStore('dst', 's0', 's1', 's2'));
1387      * var_dump($redis->sMembers('dst'));
1388      *
1389      * //int(2)
1390      * //array(2) {
1391      * //  [0]=>
1392      * //  string(1) "4"
1393      * //  [1]=>
1394      * //  string(1) "2"
1395      * //}
1396      * </pre>
1397      */
1398     public function sDiffStore( $dstKey, $key1, $key2, $keyN = null ) {}
1399 
1400     /**
1401      * Returns the contents of a set.
1402      *
1403      * @param   string  $key
1404      * @return  array   An array of elements, the contents of the set.
1405      * @link    http://redis.io/commands/smembers
1406      * @example
1407      * <pre>
1408      * $redis->delete('s');
1409      * $redis->sAdd('s', 'a');
1410      * $redis->sAdd('s', 'b');
1411      * $redis->sAdd('s', 'a');
1412      * $redis->sAdd('s', 'c');
1413      * var_dump($redis->sMembers('s'));
1414      *
1415      * //array(3) {
1416      * //  [0]=>
1417      * //  string(1) "c"
1418      * //  [1]=>
1419      * //  string(1) "a"
1420      * //  [2]=>
1421      * //  string(1) "b"
1422      * //}
1423      * // The order is random and corresponds to redis' own internal representation of the set structure.
1424      * </pre>
1425      */
1426     public function sMembers( $key ) {}
1427 
1428     /**
1429      * @see sMembers()
1430      * @param   string  $key
1431      * @link    http://redis.io/commands/smembers
1432      */
1433     public function sGetMembers( $key ) {}
1434 
1435     /**
1436      * Sets a value and returns the previous entry at that key.
1437      *
1438      * @param   string  $key
1439      * @param   string  $value
1440      * @return  string  A string, the previous value located at this key.
1441      * @link    http://redis.io/commands/getset
1442      * @example
1443      * <pre>
1444      * $redis->set('x', '42');
1445      * $exValue = $redis->getSet('x', 'lol');   // return '42', replaces x by 'lol'
1446      * $newValue = $redis->get('x')'            // return 'lol'
1447      * </pre>
1448      */
1449     public function getSet( $key, $value ) {}
1450 
1451     /**
1452      * Returns a random key.
1453      *
1454      * @return string: an existing key in redis.
1455      * @link    http://redis.io/commands/randomkey
1456      * @example
1457      * <pre>
1458      * $key = $redis->randomKey();
1459      * $surprise = $redis->get($key);  // who knows what's in there.
1460      * </pre>
1461      */
1462     public function randomKey( ) {}
1463 
1464 
1465     /**
1466      * Switches to a given database.
1467      *
1468      * @param   int     $dbindex
1469      * @return  bool    TRUE in case of success, FALSE in case of failure.
1470      * @link    http://redis.io/commands/select
1471      * @example
1472      * <pre>
1473      * $redis->select(0);       // switch to DB 0
1474      * $redis->set('x', '42');  // write 42 to x
1475      * $redis->move('x', 1);    // move to DB 1
1476      * $redis->select(1);       // switch to DB 1
1477      * $redis->get('x');        // will return 42
1478      * </pre>
1479      */
1480     public function select( $dbindex ) {}
1481 
1482     /**
1483      * Moves a key to a different database.
1484      *
1485      * @param   string  $key
1486      * @param   int     $dbindex
1487      * @return  bool:   TRUE in case of success, FALSE in case of failure.
1488      * @link    http://redis.io/commands/move
1489      * @example
1490      * <pre>
1491      * $redis->select(0);       // switch to DB 0
1492      * $redis->set('x', '42');  // write 42 to x
1493      * $redis->move('x', 1);    // move to DB 1
1494      * $redis->select(1);       // switch to DB 1
1495      * $redis->get('x');        // will return 42
1496      * </pre>
1497      */
1498     public function move( $key, $dbindex ) {}
1499 
1500     /**
1501      * Renames a key.
1502      *
1503      * @param   string  $srcKey
1504      * @param   string  $dstKey
1505      * @return  bool:   TRUE in case of success, FALSE in case of failure.
1506      * @link    http://redis.io/commands/rename
1507      * @example
1508      * <pre>
1509      * $redis->set('x', '42');
1510      * $redis->rename('x', 'y');
1511      * $redis->get('y');   // → 42
1512      * $redis->get('x');   // → `FALSE`
1513      * </pre>
1514      */
1515     public function rename( $srcKey, $dstKey ) {}
1516 
1517     /**
1518      * @see rename()
1519      * @link    http://redis.io/commands/rename
1520      * @param   string  $srcKey
1521      * @param   string  $dstKey
1522      */
1523     public function renameKey( $srcKey, $dstKey ) {}
1524 
1525     /**
1526      * Renames a key.
1527      *
1528      * Same as rename, but will not replace a key if the destination already exists.
1529      * This is the same behaviour as setNx.
1530      *
1531      * @param   string  $srcKey
1532      * @param   string  $dstKey
1533      * @return  bool:   TRUE in case of success, FALSE in case of failure.
1534      * @link    http://redis.io/commands/renamenx
1535      * @example
1536      * <pre>
1537      * $redis->set('x', '42');
1538      * $redis->rename('x', 'y');
1539      * $redis->get('y');   // → 42
1540      * $redis->get('x');   // → `FALSE`
1541      * </pre>
1542      */
1543     public function renameNx( $srcKey, $dstKey ) {}
1544 
1545     /**
1546      * Sets an expiration date (a timeout) on an item.
1547      *
1548      * @param   string  $key    The key that will disappear.
1549      * @param   int     $ttl    The key's remaining Time To Live, in seconds.
1550      * @return  bool:   TRUE in case of success, FALSE in case of failure.
1551      * @link    http://redis.io/commands/expire
1552      * @example
1553      * <pre>
1554      * $redis->set('x', '42');
1555      * $redis->setTimeout('x', 3);  // x will disappear in 3 seconds.
1556      * sleep(5);                    // wait 5 seconds
1557      * $redis->get('x');            // will return `FALSE`, as 'x' has expired.
1558      * </pre>
1559      */
1560     public function expire( $key, $ttl ) {}
1561 
1562     /**
1563      * Sets an expiration date (a timeout in milliseconds) on an item.
1564      *
1565      * @param   string  $key    The key that will disappear.
1566      * @param   int     $pttl   The key's remaining Time To Live, in milliseconds.
1567      * @return  bool:   TRUE in case of success, FALSE in case of failure.
1568      * @link    http://redis.io/commands/pexpire
1569      * @example
1570      * <pre>
1571      * $redis->set('x', '42');
1572      * $redis->pExpire('x', 11500); // x will disappear in 11500 milliseconds.
1573      * $redis->ttl('x');            // 12
1574      * $redis->pttl('x');           // 11500
1575      * </pre>
1576      */
1577     public function pExpire( $key, $ttl ) {}
1578 
1579     /**
1580      * @see expire()
1581      * @param   string  $key
1582      * @param   int     $ttl
1583      * @link    http://redis.io/commands/expire
1584      */
1585     public function setTimeout( $key, $ttl ) {}
1586 
1587     /**
1588      * Sets an expiration date (a timestamp) on an item.
1589      *
1590      * @param   string  $key        The key that will disappear.
1591      * @param   int     $timestamp  Unix timestamp. The key's date of death, in seconds from Epoch time.
1592      * @return  bool:   TRUE in case of success, FALSE in case of failure.
1593      * @link    http://redis.io/commands/expireat
1594      * @example
1595      * <pre>
1596      * $redis->set('x', '42');
1597      * $now = time(NULL);               // current timestamp
1598      * $redis->expireAt('x', $now + 3); // x will disappear in 3 seconds.
1599      * sleep(5);                        // wait 5 seconds
1600      * $redis->get('x');                // will return `FALSE`, as 'x' has expired.
1601      * </pre>
1602      */
1603     public function expireAt( $key, $timestamp ) {}
1604 
1605     /**
1606      * Sets an expiration date (a timestamp) on an item. Requires a timestamp in milliseconds
1607      *
1608      * @param   string  $key        The key that will disappear.
1609      * @param   int     $timestamp  Unix timestamp. The key's date of death, in seconds from Epoch time.
1610      * @return  bool:   TRUE in case of success, FALSE in case of failure.
1611      * @link    http://redis.io/commands/pexpireat
1612      * @example
1613      * <pre>
1614      * $redis->set('x', '42');
1615      * $redis->pExpireAt('x', 1555555555005);
1616      * echo $redis->ttl('x');                       // 218270121
1617      * echo $redis->pttl('x');                      // 218270120575
1618      * </pre>
1619      */
1620     public function pExpireAt( $key, $timestamp ) {}
1621 
1622     /**
1623      * Returns the keys that match a certain pattern.
1624      *
1625      * @param   string  $pattern pattern, using '*' as a wildcard.
1626      * @return  array   of STRING: The keys that match a certain pattern.
1627      * @link    http://redis.io/commands/keys
1628      * @example
1629      * <pre>
1630      * $allKeys = $redis->keys('*');   // all keys will match this.
1631      * $keyWithUserPrefix = $redis->keys('user*');
1632      * </pre>
1633      */
1634     public function keys( $pattern ) {}
1635 
1636     /**
1637      * @see keys()
1638      * @param   string  $pattern
1639      * @link    http://redis.io/commands/keys
1640      */
1641     public function getKeys( $pattern ) {}
1642 
1643     /**
1644      * Returns the current database's size.
1645      *
1646      * @return int:     DB size, in number of keys.
1647      * @link    http://redis.io/commands/dbsize
1648      * @example
1649      * <pre>
1650      * $count = $redis->dbSize();
1651      * echo "Redis has $count keys\n";
1652      * </pre>
1653      */
1654     public function dbSize( ) {}
1655 
1656     /**
1657      * Authenticate the connection using a password.
1658      * Warning: The password is sent in plain-text over the network.
1659      *
1660      * @param   string  $password
1661      * @return  bool:   TRUE if the connection is authenticated, FALSE otherwise.
1662      * @link    http://redis.io/commands/auth
1663      * @example $redis->auth('foobared');
1664      */
1665     public function auth( $password ) {}
1666 
1667     /**
1668      * Starts the background rewrite of AOF (Append-Only File)
1669      *
1670      * @return  bool:   TRUE in case of success, FALSE in case of failure.
1671      * @link    http://redis.io/commands/bgrewriteaof
1672      * @example $redis->bgrewriteaof();
1673      */
1674     public function bgrewriteaof( ) {}
1675 
1676     /**
1677      * Changes the slave status
1678      * Either host and port, or no parameter to stop being a slave.
1679      *
1680      * @param   string  $host [optional]
1681      * @param   int $port [optional]
1682      * @return  bool:   TRUE in case of success, FALSE in case of failure.
1683      * @link    http://redis.io/commands/slaveof
1684      * @example
1685      * <pre>
1686      * $redis->slaveof('10.0.1.7', 6379);
1687      * // ...
1688      * $redis->slaveof();
1689      * </pre>
1690      */
1691     public function slaveof( $host = '127.0.0.1', $port = 6379 ) {}
1692 
1693     /**
1694      * Describes the object pointed to by a key.
1695      * The information to retrieve (string) and the key (string).
1696      * Info can be one of the following:
1697      * - "encoding"
1698      * - "refcount"
1699      * - "idletime"
1700      *
1701      * @param   string  $string
1702      * @param   string  $key
1703      * @return  string  for "encoding", int for "refcount" and "idletime", FALSE if the key doesn't exist.
1704      * @link    http://redis.io/commands/object
1705      * @example
1706      * <pre>
1707      * $redis->object("encoding", "l"); // → ziplist
1708      * $redis->object("refcount", "l"); // → 1
1709      * $redis->object("idletime", "l"); // → 400 (in seconds, with a precision of 10 seconds).
1710      * </pre>
1711      */
1712     public function object( $string = '', $key = '' ) {}
1713 
1714     /**
1715      * Performs a synchronous save.
1716      *
1717      * @return  bool:   TRUE in case of success, FALSE in case of failure.
1718      * If a save is already running, this command will fail and return FALSE.
1719      * @link    http://redis.io/commands/save
1720      * @example $redis->save();
1721      */
1722     public function save( ) {}
1723 
1724     /**
1725      * Performs a background save.
1726      *
1727      * @return  bool:    TRUE in case of success, FALSE in case of failure.
1728      * If a save is already running, this command will fail and return FALSE.
1729      * @link    http://redis.io/commands/bgsave
1730      * @example $redis->bgSave();
1731      */
1732     public function bgsave( ) {}
1733 
1734     /**
1735      * Returns the timestamp of the last disk save.
1736      *
1737      * @return  int:    timestamp.
1738      * @link    http://redis.io/commands/lastsave
1739      * @example $redis->lastSave();
1740      */
1741     public function lastSave( ) {}
1742 
1743 
1744     /**
1745      * Returns the type of data pointed by a given key.
1746      *
1747      * @param   string  $key
1748      * @return  int
1749      *
1750      * Depending on the type of the data pointed by the key,
1751      * this method will return the following value:
1752      * - string: Redis::REDIS_STRING
1753      * - set:   Redis::REDIS_SET
1754      * - list:  Redis::REDIS_LIST
1755      * - zset:  Redis::REDIS_ZSET
1756      * - hash:  Redis::REDIS_HASH
1757      * - other: Redis::REDIS_NOT_FOUND
1758      * @link    http://redis.io/commands/type
1759      * @example $redis->type('key');
1760      */
1761     public function type( $key ) {}
1762 
1763     /**
1764      * Append specified string to the string stored in specified key.
1765      *
1766      * @param   string  $key
1767      * @param   string  $value
1768      * @return  int:    Size of the value after the append
1769      * @link    http://redis.io/commands/append
1770      * @example
1771      * <pre>
1772      * $redis->set('key', 'value1');
1773      * $redis->append('key', 'value2'); // 12
1774      * $redis->get('key');              // 'value1value2'
1775      * </pre>
1776      */
1777     public function append( $key, $value ) {}
1778 
1779 
1780     /**
1781      * Return a substring of a larger string
1782      *
1783      * @param   string  $key
1784      * @param   int     $start
1785      * @param   int     $end
1786      * @return  string: the substring
1787      * @link    http://redis.io/commands/getrange
1788      * @example
1789      * <pre>
1790      * $redis->set('key', 'string value');
1791      * $redis->getRange('key', 0, 5);   // 'string'
1792      * $redis->getRange('key', -5, -1); // 'value'
1793      * </pre>
1794      */
1795     public function getRange( $key, $start, $end ) {}
1796 
1797     /**
1798      * Return a substring of a larger string
1799      *
1800      * @deprecated
1801      * @param   string  $key
1802      * @param   int     $start
1803      * @param   int     $end
1804      */
1805     public function substr( $key, $start, $end ) {}
1806 
1807 
1808     /**
1809      * Changes a substring of a larger string.
1810      *
1811      * @param   string  $key
1812      * @param   int     $offset
1813      * @param   string  $value
1814      * @return  string: the length of the string after it was modified.
1815      * @link    http://redis.io/commands/setrange
1816      * @example
1817      * <pre>
1818      * $redis->set('key', 'Hello world');
1819      * $redis->setRange('key', 6, "redis"); // returns 11
1820      * $redis->get('key');                  // "Hello redis"
1821      * </pre>
1822      */
1823     public function setRange( $key, $offset, $value ) {}
1824 
1825     /**
1826      * Get the length of a string value.
1827      *
1828      * @param   string  $key
1829      * @return  int
1830      * @link    http://redis.io/commands/strlen
1831      * @example
1832      * <pre>
1833      * $redis->set('key', 'value');
1834      * $redis->strlen('key'); // 5
1835      * </pre>
1836      */
1837     public function strlen( $key ) {}
1838 
1839     /**
1840      * Return a single bit out of a larger string
1841      *
1842      * @param   string  $key
1843      * @param   int     $offset
1844      * @return  int:    the bit value (0 or 1)
1845      * @link    http://redis.io/commands/getbit
1846      * @example
1847      * <pre>
1848      * $redis->set('key', "\x7f");  // this is 0111 1111
1849      * $redis->getBit('key', 0);    // 0
1850      * $redis->getBit('key', 1);    // 1
1851      * </pre>
1852      */
1853     public function getBit( $key, $offset ) {}
1854 
1855     /**
1856      * Changes a single bit of a string.
1857      *
1858      * @param   string  $key
1859      * @param   int     $offset
1860      * @param   bool|int $value bool or int (1 or 0)
1861      * @return  int:    0 or 1, the value of the bit before it was set.
1862      * @link    http://redis.io/commands/setbit
1863      * @example
1864      * <pre>
1865      * $redis->set('key', "*");     // ord("*") = 42 = 0x2f = "0010 1010"
1866      * $redis->setBit('key', 5, 1); // returns 0
1867      * $redis->setBit('key', 7, 1); // returns 0
1868      * $redis->get('key');          // chr(0x2f) = "/" = b("0010 1111")
1869      * </pre>
1870      */
1871     public function setBit( $key, $offset, $value ) {}
1872 
1873     /**
1874      * Count bits in a string.
1875      *
1876      * @param   string  $key
1877      * @return  int     The number of bits set to 1 in the value behind the input key.
1878      * @link    http://redis.io/commands/bitcount
1879      * @example
1880      * <pre>
1881      * $redis->set('bit', '345'); // // 11 0011  0011 0100  0011 0101
1882      * var_dump( $redis->bitCount('bit', 0, 0) ); // int(4)
1883      * var_dump( $redis->bitCount('bit', 1, 1) ); // int(3)
1884      * var_dump( $redis->bitCount('bit', 2, 2) ); // int(4)
1885      * var_dump( $redis->bitCount('bit', 0, 2) ); // int(11)
1886      * </pre>
1887      */
1888     public function bitCount( $key ) {}
1889 
1890     /**
1891      * Bitwise operation on multiple keys.
1892      *
1893      * @param   string  $operation  either "AND", "OR", "NOT", "XOR"
1894      * @param   string  $retKey     return key
1895      * @param   string  $key1
1896      * @param   string  $key2
1897      * @return  int     The size of the string stored in the destination key.
1898      * @link    http://redis.io/commands/bitop
1899      * @example
1900      * <pre>
1901      * $redis->set('bit1', '1'); // 11 0001
1902      * $redis->set('bit2', '2'); // 11 0010
1903      *
1904      * $redis->bitOp('AND', 'bit', 'bit1', 'bit2'); // bit = 110000
1905      * $redis->bitOp('OR',  'bit', 'bit1', 'bit2'); // bit = 110011
1906      * $redis->bitOp('NOT', 'bit', 'bit1', 'bit2'); // bit = 110011
1907      * $redis->bitOp('XOR', 'bit', 'bit1', 'bit2'); // bit = 11
1908      * </pre>
1909      */
1910     public function bitOp( $operation, $retKey, $key1, $key2, $key3 = null ) {}
1911 
1912     /**
1913      * Removes all entries from the current database.
1914      *
1915      * @return  bool: Always TRUE.
1916      * @link    http://redis.io/commands/flushdb
1917      * @example $redis->flushDB();
1918      */
1919     public function flushDB( ) {}
1920 
1921     /**
1922      * Removes all entries from all databases.
1923      *
1924      * @return  bool: Always TRUE.
1925      * @link    http://redis.io/commands/flushall
1926      * @example $redis->flushAll();
1927      */
1928     public function flushAll( ) {}
1929 
1930     /**
1931      * Sort
1932      *
1933      * @param   string  $key
1934      * @param   array   $option array(key => value, ...) - optional, with the following keys and values:
1935      * - 'by' => 'some_pattern_*',
1936      * - 'limit' => array(0, 1),
1937      * - 'get' => 'some_other_pattern_*' or an array of patterns,
1938      * - 'sort' => 'asc' or 'desc',
1939      * - 'alpha' => TRUE,
1940      * - 'store' => 'external-key'
1941      * @return  array
1942      * An array of values, or a number corresponding to the number of elements stored if that was used.
1943      * @link    http://redis.io/commands/sort
1944      * @example
1945      * <pre>
1946      * $redis->delete('s');
1947      * $redis->sadd('s', 5);
1948      * $redis->sadd('s', 4);
1949      * $redis->sadd('s', 2);
1950      * $redis->sadd('s', 1);
1951      * $redis->sadd('s', 3);
1952      *
1953      * var_dump($redis->sort('s')); // 1,2,3,4,5
1954      * var_dump($redis->sort('s', array('sort' => 'desc'))); // 5,4,3,2,1
1955      * var_dump($redis->sort('s', array('sort' => 'desc', 'store' => 'out'))); // (int)5
1956      * </pre>
1957      */
1958     public function sort( $key, $option = null ) {}
1959 
1960 
1961     /**
1962      * Returns an associative array of strings and integers
1963      * @param   string   $option    Optional. The option to provide redis.
1964      * SERVER | CLIENTS | MEMORY | PERSISTENCE | STATS | REPLICATION | CPU | CLASTER | KEYSPACE | COMANDSTATS
1965      *
1966      * Returns an associative array of strings and integers, with the following keys:
1967      * - redis_version
1968      * - redis_git_sha1
1969      * - redis_git_dirty
1970      * - arch_bits
1971      * - multiplexing_api
1972      * - process_id
1973      * - uptime_in_seconds
1974      * - uptime_in_days
1975      * - lru_clock
1976      * - used_cpu_sys
1977      * - used_cpu_user
1978      * - used_cpu_sys_children
1979      * - used_cpu_user_children
1980      * - connected_clients
1981      * - connected_slaves
1982      * - client_longest_output_list
1983      * - client_biggest_input_buf
1984      * - blocked_clients
1985      * - used_memory
1986      * - used_memory_human
1987      * - used_memory_peak
1988      * - used_memory_peak_human
1989      * - mem_fragmentation_ratio
1990      * - mem_allocator
1991      * - loading
1992      * - aof_enabled
1993      * - changes_since_last_save
1994      * - bgsave_in_progress
1995      * - last_save_time
1996      * - total_connections_received
1997      * - total_commands_processed
1998      * - expired_keys
1999      * - evicted_keys
2000      * - keyspace_hits
2001      * - keyspace_misses
2002      * - hash_max_zipmap_entries
2003      * - hash_max_zipmap_value
2004      * - pubsub_channels
2005      * - pubsub_patterns
2006      * - latest_fork_usec
2007      * - vm_enabled
2008      * - role
2009      * @link    http://redis.io/commands/info
2010      * @return string
2011      * @example
2012      * <pre>
2013      * $redis->info();
2014      *
2015      * or
2016      *
2017      * $redis->info("COMMANDSTATS"); //Information on the commands that have been run (>=2.6 only)
2018      * $redis->info("CPU"); // just CPU information from Redis INFO
2019      * </pre>
2020      */
2021     public function info( $option = null ) {}
2022 
2023     /**
2024      * Resets the statistics reported by Redis using the INFO command (`info()` function).
2025      * These are the counters that are reset:
2026      *      - Keyspace hits
2027      *      - Keyspace misses
2028      *      - Number of commands processed
2029      *      - Number of connections received
2030      *      - Number of expired keys
2031      *
2032      * @return bool: `TRUE` in case of success, `FALSE` in case of failure.
2033      * @example $redis->resetStat();
2034      * @link http://redis.io/commands/config-resetstat
2035      */
2036     public function resetStat( ) {}
2037 
2038     /**
2039      * Returns the time to live left for a given key, in seconds. If the key doesn't exist, FALSE is returned.
2040      *
2041      * @param   string  $key
2042      * @return  int,    the time left to live in seconds.
2043      * @link    http://redis.io/commands/ttl
2044      * @example $redis->ttl('key');
2045      */
2046     public function ttl( $key ) {}
2047 
2048     /**
2049      * Returns a time to live left for a given key, in milliseconds.
2050      *
2051      * If the key doesn't exist, FALSE is returned.
2052      *
2053      * @param   string  $key
2054      * @return  int     the time left to live in milliseconds.
2055      * @link    http://redis.io/commands/pttl
2056      * @example $redis->pttl('key');
2057      */
2058     public function pttl( $key ) {}
2059 
2060     /**
2061      * Remove the expiration timer from a key.
2062      *
2063      * @param   string  $key
2064      * @return  bool:   TRUE if a timeout was removed, FALSE if the key didn’t exist or didn’t have an expiration timer.
2065      * @link    http://redis.io/commands/persist
2066      * @example $redis->persist('key');
2067      */
2068     public function persist( $key ) {}
2069 
2070     /**
2071      * Sets multiple key-value pairs in one atomic command.
2072      * MSETNX only returns TRUE if all the keys were set (see SETNX).
2073      *
2074      * @param   array(key => value) $array Pairs: array(key => value, ...)
2075      * @return  bool    TRUE in case of success, FALSE in case of failure.
2076      * @link    http://redis.io/commands/mset
2077      * @example
2078      * <pre>
2079      * $redis->mset(array('key0' => 'value0', 'key1' => 'value1'));
2080      * var_dump($redis->get('key0'));
2081      * var_dump($redis->get('key1'));
2082      * // Output:
2083      * // string(6) "value0"
2084      * // string(6) "value1"
2085      * </pre>
2086      */
2087     public function mset( array $array ) {}
2088 
2089 
2090     /**
2091      * Returns the values of all specified keys.
2092      *
2093      * For every key that does not hold a string value or does not exist,
2094      * the special value false is returned. Because of this, the operation never fails.
2095      *
2096      * @param array $array
2097      * @return array
2098      * @link http://redis.io/commands/mget
2099      * @example
2100      * <pre>
2101      * $redis->delete('x', 'y', 'z', 'h');    // remove x y z
2102      * $redis->mset(array('x' => 'a', 'y' => 'b', 'z' => 'c'));
2103      * $redis->hset('h', 'field', 'value');
2104      * var_dump($redis->mget(array('x', 'y', 'z', 'h')));
2105      * // Output:
2106      * // array(3) {
2107      * // [0]=>
2108      * // string(1) "a"
2109      * // [1]=>
2110      * // string(1) "b"
2111      * // [2]=>
2112      * // string(1) "c"
2113      * // [3]=>
2114      * // bool(false)
2115      * // }
2116      * </pre>
2117      */
2118     public function mget( array $array ) {}
2119 
2120     /**
2121      * @see mset()
2122      * @param   array $array
2123      * @return  int 1 (if the keys were set) or 0 (no key was set)
2124      * @link    http://redis.io/commands/msetnx
2125      */
2126     public function msetnx( array $array ) {}
2127 
2128     /**
2129      * Pops a value from the tail of a list, and pushes it to the front of another list.
2130      * Also return this value.
2131      *
2132      * @since   redis >= 1.1
2133      * @param   string  $srcKey
2134      * @param   string  $dstKey
2135      * @return  string  The element that was moved in case of success, FALSE in case of failure.
2136      * @link    http://redis.io/commands/rpoplpush
2137      * @example
2138      * <pre>
2139      * $redis->delete('x', 'y');
2140      *
2141      * $redis->lPush('x', 'abc');
2142      * $redis->lPush('x', 'def');
2143      * $redis->lPush('y', '123');
2144      * $redis->lPush('y', '456');
2145      *
2146      * // move the last of x to the front of y.
2147      * var_dump($redis->rpoplpush('x', 'y'));
2148      * var_dump($redis->lRange('x', 0, -1));
2149      * var_dump($redis->lRange('y', 0, -1));
2150      *
2151      * //Output:
2152      * //
2153      * //string(3) "abc"
2154      * //array(1) {
2155      * //  [0]=>
2156      * //  string(3) "def"
2157      * //}
2158      * //array(3) {
2159      * //  [0]=>
2160      * //  string(3) "abc"
2161      * //  [1]=>
2162      * //  string(3) "456"
2163      * //  [2]=>
2164      * //  string(3) "123"
2165      * //}
2166      * </pre>
2167      */
2168     public function rpoplpush( $srcKey, $dstKey ) {}
2169 
2170     /**
2171      * A blocking version of rpoplpush, with an integral timeout in the third parameter.
2172      *
2173      * @param   string  $srcKey
2174      * @param   string  $dstKey
2175      * @param   int     $timeout
2176      * @return  string  The element that was moved in case of success, FALSE in case of timeout.
2177      * @link    http://redis.io/commands/brpoplpush
2178      */
2179     public function brpoplpush( $srcKey, $dstKey, $timeout ) {}
2180 
2181     /**
2182      * Adds the specified member with a given score to the sorted set stored at key.
2183      *
2184      * @param   string  $key    Required key
2185      * @param   float   $score1 Required score
2186      * @param   string  $value1 Required value
2187      * @param   float   $score2 Optional score
2188      * @param   string  $value2 Optional value
2189      * @param   float   $scoreN Optional score
2190      * @param   string  $valueN Optional value
2191      * @return  int     Number of values added
2192      * @link    http://redis.io/commands/zadd
2193      * @example
2194      * <pre>
2195      * <pre>
2196      * $redis->zAdd('z', 1, 'v2', 2, 'v2', 3, 'v3', 4, 'v4' );  // int(2)
2197      * $redis->zRem('z', 'v2', 'v3');                           // int(2)
2198      * var_dump( $redis->zRange('z', 0, -1) );
2199      * //// Output:
2200      * // array(2) {
2201      * //   [0]=> string(2) "v1"
2202      * //   [1]=> string(2) "v4"
2203      * // }
2204      * </pre>
2205      * </pre>
2206      */
2207     public function zAdd( $key, $score1, $value1, $score2 = null, $value2 = null, $scoreN = null, $valueN = null ) {}
2208 
2209     /**
2210      * Returns a range of elements from the ordered set stored at the specified key,
2211      * with values in the range [start, end]. start and stop are interpreted as zero-based indices:
2212      * 0 the first element,
2213      * 1 the second ...
2214      * -1 the last element,
2215      * -2 the penultimate ...
2216      *
2217      * @param   string  $key
2218      * @param   int     $start
2219      * @param   int     $end
2220      * @param   bool    $withscores
2221      * @return  array   Array containing the values in specified range.
2222      * @link    http://redis.io/commands/zrange
2223      * @example
2224      * <pre>
2225      * $redis->zAdd('key1', 0, 'val0');
2226      * $redis->zAdd('key1', 2, 'val2');
2227      * $redis->zAdd('key1', 10, 'val10');
2228      * $redis->zRange('key1', 0, -1); // array('val0', 'val2', 'val10')
2229      * // with scores
2230      * $redis->zRange('key1', 0, -1, true); // array('val0' => 0, 'val2' => 2, 'val10' => 10)
2231      * </pre>
2232      */
2233     public function zRange( $key, $start, $end, $withscores = null ) {}
2234 
2235     /**
2236      * Deletes a specified member from the ordered set.
2237      *
2238      * @param   string  $key
2239      * @param   string  $member1
2240      * @param   string  $member2
2241      * @param   string  $memberN
2242      * @return  int     Number of deleted values
2243      * @link    http://redis.io/commands/zrem
2244      * @example
2245      * <pre>
2246      * $redis->zAdd('z', 1, 'v2', 2, 'v2', 3, 'v3', 4, 'v4' );  // int(2)
2247      * $redis->zRem('z', 'v2', 'v3');                           // int(2)
2248      * var_dump( $redis->zRange('z', 0, -1) );
2249      * //// Output:
2250      * // array(2) {
2251      * //   [0]=> string(2) "v1"
2252      * //   [1]=> string(2) "v4"
2253      * // }
2254      * </pre>
2255      */
2256     public function zRem( $key, $member1, $member2 = null, $memberN = null ) {}
2257 
2258     /**
2259      * @see zRem()
2260      * @param   string  $key
2261      * @param   string  $member1
2262      * @param   string  $member2
2263      * @param   string  $memberN
2264      * @return  int     Number of deleted values
2265      * @link    http://redis.io/commands/zrem
2266      */
2267     public function zDelete( $key, $member1, $member2 = null, $memberN = null ) {}
2268 
2269     /**
2270      * Returns the elements of the sorted set stored at the specified key in the range [start, end]
2271      * in reverse order. start and stop are interpretated as zero-based indices:
2272      * 0 the first element,
2273      * 1 the second ...
2274      * -1 the last element,
2275      * -2 the penultimate ...
2276      *
2277      * @param   string  $key
2278      * @param   int     $start
2279      * @param   int     $end
2280      * @param   bool    $withscore
2281      * @return  array   Array containing the values in specified range.
2282      * @link    http://redis.io/commands/zrevrange
2283      * @example
2284      * <pre>
2285      * $redis->zAdd('key', 0, 'val0');
2286      * $redis->zAdd('key', 2, 'val2');
2287      * $redis->zAdd('key', 10, 'val10');
2288      * $redis->zRevRange('key', 0, -1); // array('val10', 'val2', 'val0')
2289      *
2290      * // with scores
2291      * $redis->zRevRange('key', 0, -1, true); // array('val10' => 10, 'val2' => 2, 'val0' => 0)
2292      * </pre>
2293      */
2294     public function zRevRange( $key, $start, $end, $withscore = null ) {}
2295 
2296     /**
2297      * Returns the elements of the sorted set stored at the specified key which have scores in the
2298      * range [start,end]. Adding a parenthesis before start or end excludes it from the range.
2299      * +inf and -inf are also valid limits.
2300      *
2301      * zRevRangeByScore returns the same items in reverse order, when the start and end parameters are swapped.
2302      *
2303      * @param   string  $key
2304      * @param   int     $start
2305      * @param   int     $end
2306      * @param   array   $options Two options are available:
2307      *                      - withscores => TRUE,
2308      *                      - and limit => array($offset, $count)
2309      * @return  array   Array containing the values in specified range.
2310      * @link    http://redis.io/commands/zrangebyscore
2311      * @example
2312      * <pre>
2313      * $redis->zAdd('key', 0, 'val0');
2314      * $redis->zAdd('key', 2, 'val2');
2315      * $redis->zAdd('key', 10, 'val10');
2316      * $redis->zRangeByScore('key', 0, 3);                                          // array('val0', 'val2')
2317      * $redis->zRangeByScore('key', 0, 3, array('withscores' => TRUE);              // array('val0' => 0, 'val2' => 2)
2318      * $redis->zRangeByScore('key', 0, 3, array('limit' => array(1, 1));                        // array('val2' => 2)
2319      * $redis->zRangeByScore('key', 0, 3, array('limit' => array(1, 1));                        // array('val2')
2320      * $redis->zRangeByScore('key', 0, 3, array('withscores' => TRUE, 'limit' => array(1, 1));  // array('val2' => 2)
2321      * </pre>
2322      */
2323     public function zRangeByScore( $key, $start, $end, array $options = array() ) {}
2324 
2325     /**
2326      * @see zRangeByScore()
2327      * @param   string  $key
2328      * @param   int     $start
2329      * @param   int     $end
2330      * @param   array   $options
2331      *
2332      * @return     array
2333      */
2334     public function zRevRangeByScore( $key, $start, $end, array $options = array() ) {}
2335 
2336     /**
2337      * Returns the number of elements of the sorted set stored at the specified key which have
2338      * scores in the range [start,end]. Adding a parenthesis before start or end excludes it
2339      * from the range. +inf and -inf are also valid limits.
2340      *
2341      * @param   string  $key
2342      * @param   string  $start
2343      * @param   string  $end
2344      * @return  int     the size of a corresponding zRangeByScore.
2345      * @link    http://redis.io/commands/zcount
2346      * @example
2347      * <pre>
2348      * $redis->zAdd('key', 0, 'val0');
2349      * $redis->zAdd('key', 2, 'val2');
2350      * $redis->zAdd('key', 10, 'val10');
2351      * $redis->zCount('key', 0, 3); // 2, corresponding to array('val0', 'val2')
2352      * </pre>
2353      */
2354     public function zCount( $key, $start, $end ) {}
2355 
2356     /**
2357      * Deletes the elements of the sorted set stored at the specified key which have scores in the range [start,end].
2358      *
2359      * @param   string          $key
2360      * @param   float|string    $start double or "+inf" or "-inf" string
2361      * @param   float|string    $end double or "+inf" or "-inf" string
2362      * @return  int             The number of values deleted from the sorted set
2363      * @link    http://redis.io/commands/zremrangebyscore
2364      * @example
2365      * <pre>
2366      * $redis->zAdd('key', 0, 'val0');
2367      * $redis->zAdd('key', 2, 'val2');
2368      * $redis->zAdd('key', 10, 'val10');
2369      * $redis->zRemRangeByScore('key', 0, 3); // 2
2370      * </pre>
2371      */
2372     public function zRemRangeByScore( $key, $start, $end ) {}
2373 
2374     /**
2375      * @see zRemRangeByScore()
2376      * @param string    $key
2377      * @param float     $start
2378      * @param float     $end
2379      */
2380     public function zDeleteRangeByScore( $key, $start, $end ) {}
2381 
2382     /**
2383      * Deletes the elements of the sorted set stored at the specified key which have rank in the range [start,end].
2384      *
2385      * @param   string  $key
2386      * @param   int     $start
2387      * @param   int     $end
2388      * @return  int     The number of values deleted from the sorted set
2389      * @link    http://redis.io/commands/zremrangebyrank
2390      * @example
2391      * <pre>
2392      * $redis->zAdd('key', 1, 'one');
2393      * $redis->zAdd('key', 2, 'two');
2394      * $redis->zAdd('key', 3, 'three');
2395      * $redis->zRemRangeByRank('key', 0, 1); // 2
2396      * $redis->zRange('key', 0, -1, array('withscores' => TRUE)); // array('three' => 3)
2397      * </pre>
2398      */
2399     public function zRemRangeByRank( $key, $start, $end ) {}
2400 
2401     /**
2402      * @see zRemRangeByRank()
2403      * @param   string  $key
2404      * @param   int     $start
2405      * @param   int     $end
2406      * @link    http://redis.io/commands/zremrangebyscore
2407      */
2408     public function zDeleteRangeByRank( $key, $start, $end ) {}
2409 
2410     /**
2411      * Returns the cardinality of an ordered set.
2412      *
2413      * @param   string  $key
2414      * @return  int     the set's cardinality
2415      * @link    http://redis.io/commands/zsize
2416      * @example
2417      * <pre>
2418      * $redis->zAdd('key', 0, 'val0');
2419      * $redis->zAdd('key', 2, 'val2');
2420      * $redis->zAdd('key', 10, 'val10');
2421      * $redis->zCard('key');            // 3
2422      * </pre>
2423      */
2424     public function zCard( $key ) {}
2425 
2426     /**
2427      * @see zCard()
2428      * @param string $key
2429      */
2430     public function zSize( $key ) {}
2431 
2432     /**
2433      * Returns the score of a given member in the specified sorted set.
2434      *
2435      * @param   string  $key
2436      * @param   string  $member
2437      * @return  float
2438      * @link    http://redis.io/commands/zscore
2439      * @example
2440      * <pre>
2441      * $redis->zAdd('key', 2.5, 'val2');
2442      * $redis->zScore('key', 'val2'); // 2.5
2443      * </pre>
2444      */
2445     public function zScore( $key, $member ) {}
2446 
2447     /**
2448      * Returns the rank of a given member in the specified sorted set, starting at 0 for the item
2449      * with the smallest score. zRevRank starts at 0 for the item with the largest score.
2450      *
2451      * @param   string  $key
2452      * @param   string  $member
2453      * @return  int     the item's score.
2454      * @link    http://redis.io/commands/zrank
2455      * @example
2456      * <pre>
2457      * $redis->delete('z');
2458      * $redis->zAdd('key', 1, 'one');
2459      * $redis->zAdd('key', 2, 'two');
2460      * $redis->zRank('key', 'one');     // 0
2461      * $redis->zRank('key', 'two');     // 1
2462      * $redis->zRevRank('key', 'one');  // 1
2463      * $redis->zRevRank('key', 'two');  // 0
2464      * </pre>
2465      */
2466     public function zRank( $key, $member ) {}
2467 
2468     /**
2469      * @see zRank()
2470      * @param  string $key
2471      * @param  string $member
2472      * @return int    the item's score
2473      * @link   http://redis.io/commands/zrevrank
2474      */
2475     public function zRevRank( $key, $member ) {}
2476 
2477     /**
2478      * Increments the score of a member from a sorted set by a given amount.
2479      *
2480      * @param   string  $key
2481      * @param   float   $value (double) value that will be added to the member's score
2482      * @param   string  $member
2483      * @return  float   the new value
2484      * @link    http://redis.io/commands/zincrby
2485      * @example
2486      * <pre>
2487      * $redis->delete('key');
2488      * $redis->zIncrBy('key', 2.5, 'member1');  // key or member1 didn't exist, so member1's score is to 0
2489      *                                          // before the increment and now has the value 2.5
2490      * $redis->zIncrBy('key', 1, 'member1');    // 3.5
2491      * </pre>
2492      */
2493     public function zIncrBy( $key, $value, $member ) {}
2494 
2495     /**
2496      * Creates an union of sorted sets given in second argument.
2497      * The result of the union will be stored in the sorted set defined by the first argument.
2498      * The third optionnel argument defines weights to apply to the sorted sets in input.
2499      * In this case, the weights will be multiplied by the score of each element in the sorted set
2500      * before applying the aggregation. The forth argument defines the AGGREGATE option which
2501      * specify how the results of the union are aggregated.
2502      *
2503      * @param string    $Output
2504      * @param array     $ZSetKeys
2505      * @param array     $Weights
2506      * @param string    $aggregateFunction  Either "SUM", "MIN", or "MAX": defines the behaviour to use on
2507      * duplicate entries during the zUnion.
2508      * @return int The number of values in the new sorted set.
2509      * @link    http://redis.io/commands/zunionstore
2510      * @example
2511      * <pre>
2512      * $redis->delete('k1');
2513      * $redis->delete('k2');
2514      * $redis->delete('k3');
2515      * $redis->delete('ko1');
2516      * $redis->delete('ko2');
2517      * $redis->delete('ko3');
2518      *
2519      * $redis->zAdd('k1', 0, 'val0');
2520      * $redis->zAdd('k1', 1, 'val1');
2521      *
2522      * $redis->zAdd('k2', 2, 'val2');
2523      * $redis->zAdd('k2', 3, 'val3');
2524      *
2525      * $redis->zUnion('ko1', array('k1', 'k2')); // 4, 'ko1' => array('val0', 'val1', 'val2', 'val3')
2526      *
2527      * // Weighted zUnion
2528      * $redis->zUnion('ko2', array('k1', 'k2'), array(1, 1)); // 4, 'ko2' => array('val0', 'val1', 'val2', 'val3')
2529      * $redis->zUnion('ko3', array('k1', 'k2'), array(5, 1)); // 4, 'ko3' => array('val0', 'val2', 'val3', 'val1')
2530      * </pre>
2531      */
2532     public function zUnion($Output, $ZSetKeys, array $Weights = null, $aggregateFunction = 'SUM') {}
2533 
2534     /**
2535      * Creates an intersection of sorted sets given in second argument.
2536      * The result of the union will be stored in the sorted set defined by the first argument.
2537      * The third optional argument defines weights to apply to the sorted sets in input.
2538      * In this case, the weights will be multiplied by the score of each element in the sorted set
2539      * before applying the aggregation. The forth argument defines the AGGREGATE option which
2540      * specify how the results of the union are aggregated.
2541      *
2542      * @param   string  $Output
2543      * @param   array   $ZSetKeys
2544      * @param   array   $Weights
2545      * @param   string  $aggregateFunction Either "SUM", "MIN", or "MAX":
2546      * defines the behaviour to use on duplicate entries during the zInter.
2547      * @return  int     The number of values in the new sorted set.
2548      * @link    http://redis.io/commands/zinterstore
2549      * @example
2550      * <pre>
2551      * $redis->delete('k1');
2552      * $redis->delete('k2');
2553      * $redis->delete('k3');
2554      *
2555      * $redis->delete('ko1');
2556      * $redis->delete('ko2');
2557      * $redis->delete('ko3');
2558      * $redis->delete('ko4');
2559      *
2560      * $redis->zAdd('k1', 0, 'val0');
2561      * $redis->zAdd('k1', 1, 'val1');
2562      * $redis->zAdd('k1', 3, 'val3');
2563      *
2564      * $redis->zAdd('k2', 2, 'val1');
2565      * $redis->zAdd('k2', 3, 'val3');
2566      *
2567      * $redis->zInter('ko1', array('k1', 'k2'));               // 2, 'ko1' => array('val1', 'val3')
2568      * $redis->zInter('ko2', array('k1', 'k2'), array(1, 1));  // 2, 'ko2' => array('val1', 'val3')
2569      *
2570      * // Weighted zInter
2571      * $redis->zInter('ko3', array('k1', 'k2'), array(1, 5), 'min'); // 2, 'ko3' => array('val1', 'val3')
2572      * $redis->zInter('ko4', array('k1', 'k2'), array(1, 5), 'max'); // 2, 'ko4' => array('val3', 'val1')
2573      * </pre>
2574      */
2575     public function zInter($Output, $ZSetKeys, array $Weights = null, $aggregateFunction = 'SUM') {}
2576 
2577     /**
2578      * Adds a value to the hash stored at key. If this value is already in the hash, FALSE is returned.
2579      *
2580      * @param string $key
2581      * @param string $hashKey
2582      * @param string $value
2583      * @return int
2584      * 1 if value didn't exist and was added successfully,
2585      * 0 if the value was already present and was replaced, FALSE if there was an error.
2586      * @link    http://redis.io/commands/hset
2587      * @example
2588      * <pre>
2589      * $redis->delete('h')
2590      * $redis->hSet('h', 'key1', 'hello');  // 1, 'key1' => 'hello' in the hash at "h"
2591      * $redis->hGet('h', 'key1');           // returns "hello"
2592      *
2593      * $redis->hSet('h', 'key1', 'plop');   // 0, value was replaced.
2594      * $redis->hGet('h', 'key1');           // returns "plop"
2595      * </pre>
2596      */
2597     public function hSet( $key, $hashKey, $value ) {}
2598 
2599     /**
2600      * Adds a value to the hash stored at key only if this field isn't already in the hash.
2601      *
2602      * @param   string  $key
2603      * @param   string  $hashKey
2604      * @param   string  $value
2605      * @return  bool    TRUE if the field was set, FALSE if it was already present.
2606      * @link    http://redis.io/commands/hsetnx
2607      * @example
2608      * <pre>
2609      * $redis->delete('h')
2610      * $redis->hSetNx('h', 'key1', 'hello'); // TRUE, 'key1' => 'hello' in the hash at "h"
2611      * $redis->hSetNx('h', 'key1', 'world'); // FALSE, 'key1' => 'hello' in the hash at "h". No change since the field
2612      * wasn't replaced.
2613      * </pre>
2614      */
2615     public function hSetNx( $key, $hashKey, $value ) {}
2616 
2617     /**
2618      * Gets a value from the hash stored at key.
2619      * If the hash table doesn't exist, or the key doesn't exist, FALSE is returned.
2620      *
2621      * @param   string  $key
2622      * @param   string  $hashKey
2623      * @return  string  The value, if the command executed successfully BOOL FALSE in case of failure
2624      * @link    http://redis.io/commands/hget
2625      */
2626     public function hGet($key, $hashKey) {}
2627 
2628     /**
2629      * Returns the length of a hash, in number of items
2630      *
2631      * @param   string  $key
2632      * @return  int     the number of items in a hash, FALSE if the key doesn't exist or isn't a hash.
2633      * @link    http://redis.io/commands/hlen
2634      * @example
2635      * <pre>
2636      * $redis->delete('h')
2637      * $redis->hSet('h', 'key1', 'hello');
2638      * $redis->hSet('h', 'key2', 'plop');
2639      * $redis->hLen('h'); // returns 2
2640      * </pre>
2641      */
2642     public function hLen( $key ) {}
2643 
2644     /**
2645      * Removes a values from the hash stored at key.
2646      * If the hash table doesn't exist, or the key doesn't exist, FALSE is returned.
2647      *
2648      * @param   string  $key
2649      * @param   string  $hashKey1
2650      * @param   string  $hashKey2
2651      * @param   string  $hashKeyN
2652      * @return  int     Number of deleted fields
2653      * @link    http://redis.io/commands/hdel
2654      * @example
2655      * <pre>
2656      * $redis->hMSet('h',
2657      *               array(
2658      *                    'f1' => 'v1',
2659      *                    'f2' => 'v2',
2660      *                    'f3' => 'v3',
2661      *                    'f4' => 'v4',
2662      *               ));
2663      *
2664      * var_dump( $redis->hDel('h', 'f1') );        // int(1)
2665      * var_dump( $redis->hDel('h', 'f2', 'f3') );  // int(2)
2666      * s
2667      * var_dump( $redis->hGetAll('h') );
2668      * //// Output:
2669      * //  array(1) {
2670      * //    ["f4"]=> string(2) "v4"
2671      * //  }
2672      * </pre>
2673      */
2674     public function hDel( $key, $hashKey1, $hashKey2 = null, $hashKeyN = null ) {}
2675 
2676     /**
2677      * Returns the keys in a hash, as an array of strings.
2678      *
2679      * @param   string  $key
2680      * @return  array   An array of elements, the keys of the hash. This works like PHP's array_keys().
2681      * @link    http://redis.io/commands/hkeys
2682      * @example
2683      * <pre>
2684      * $redis->delete('h');
2685      * $redis->hSet('h', 'a', 'x');
2686      * $redis->hSet('h', 'b', 'y');
2687      * $redis->hSet('h', 'c', 'z');
2688      * $redis->hSet('h', 'd', 't');
2689      * var_dump($redis->hKeys('h'));
2690      *
2691      * // Output:
2692      * // array(4) {
2693      * // [0]=>
2694      * // string(1) "a"
2695      * // [1]=>
2696      * // string(1) "b"
2697      * // [2]=>
2698      * // string(1) "c"
2699      * // [3]=>
2700      * // string(1) "d"
2701      * // }
2702      * // The order is random and corresponds to redis' own internal representation of the set structure.
2703      * </pre>
2704      */
2705     public function hKeys( $key ) {}
2706 
2707     /**
2708      * Returns the values in a hash, as an array of strings.
2709      *
2710      * @param   string  $key
2711      * @return  array   An array of elements, the values of the hash. This works like PHP's array_values().
2712      * @link    http://redis.io/commands/hvals
2713      * @example
2714      * <pre>
2715      * $redis->delete('h');
2716      * $redis->hSet('h', 'a', 'x');
2717      * $redis->hSet('h', 'b', 'y');
2718      * $redis->hSet('h', 'c', 'z');
2719      * $redis->hSet('h', 'd', 't');
2720      * var_dump($redis->hVals('h'));
2721      *
2722      * // Output
2723      * // array(4) {
2724      * //   [0]=>
2725      * //   string(1) "x"
2726      * //   [1]=>
2727      * //   string(1) "y"
2728      * //   [2]=>
2729      * //   string(1) "z"
2730      * //   [3]=>
2731      * //   string(1) "t"
2732      * // }
2733      * // The order is random and corresponds to redis' own internal representation of the set structure.
2734      * </pre>
2735      */
2736     public function hVals( $key ) {}
2737 
2738     /**
2739      * Returns the whole hash, as an array of strings indexed by strings.
2740      *
2741      * @param   string  $key
2742      * @return  array   An array of elements, the contents of the hash.
2743      * @link    http://redis.io/commands/hgetall
2744      * @example
2745      * <pre>
2746      * $redis->delete('h');
2747      * $redis->hSet('h', 'a', 'x');
2748      * $redis->hSet('h', 'b', 'y');
2749      * $redis->hSet('h', 'c', 'z');
2750      * $redis->hSet('h', 'd', 't');
2751      * var_dump($redis->hGetAll('h'));
2752      *
2753      * // Output:
2754      * // array(4) {
2755      * //   ["a"]=>
2756      * //   string(1) "x"
2757      * //   ["b"]=>
2758      * //   string(1) "y"
2759      * //   ["c"]=>
2760      * //   string(1) "z"
2761      * //   ["d"]=>
2762      * //   string(1) "t"
2763      * // }
2764      * // The order is random and corresponds to redis' own internal representation of the set structure.
2765      * </pre>
2766      */
2767     public function hGetAll( $key ) {}
2768 
2769     /**
2770      * Verify if the specified member exists in a key.
2771      *
2772      * @param   string  $key
2773      * @param   string  $hashKey
2774      * @return  bool:   If the member exists in the hash table, return TRUE, otherwise return FALSE.
2775      * @link    http://redis.io/commands/hexists
2776      * @example
2777      * <pre>
2778      * $redis->hSet('h', 'a', 'x');
2779      * $redis->hExists('h', 'a');               //  TRUE
2780      * $redis->hExists('h', 'NonExistingKey');  // FALSE
2781      * </pre>
2782      */
2783     public function hExists( $key, $hashKey ) {}
2784 
2785     /**
2786      * Increments the value of a member from a hash by a given amount.
2787      *
2788      * @param   string  $key
2789      * @param   string  $hashKey
2790      * @param   int     $value (integer) value that will be added to the member's value
2791      * @return  int     the new value
2792      * @link    http://redis.io/commands/hincrby
2793      * @example
2794      * <pre>
2795      * $redis->delete('h');
2796      * $redis->hIncrBy('h', 'x', 2); // returns 2: h[x] = 2 now.
2797      * $redis->hIncrBy('h', 'x', 1); // h[x] ← 2 + 1. Returns 3
2798      * </pre>
2799      */
2800     public function hIncrBy( $key, $hashKey, $value ) {}
2801 
2802     /**
2803      * Increment the float value of a hash field by the given amount
2804      * @param   string  $key
2805      * @param   string  $field
2806      * @param   float   $increment
2807      * @return  float
2808      * @link    http://redis.io/commands/hincrbyfloat
2809      * @example
2810      * <pre>
2811      * $redis = new Redis();
2812      * $redis->connect('127.0.0.1');
2813      * $redis->hset('h', 'float', 3);
2814      * $redis->hset('h', 'int',   3);
2815      * var_dump( $redis->hIncrByFloat('h', 'float', 1.5) ); // float(4.5)
2816      *
2817      * var_dump( $redis->hGetAll('h') );
2818      *
2819      * // Output
2820      *  array(2) {
2821      *    ["float"]=>
2822      *    string(3) "4.5"
2823      *    ["int"]=>
2824      *    string(1) "3"
2825      *  }
2826      * </pre>
2827      */
2828     public function hIncrByFloat( $key, $field, $increment ) {}
2829 
2830     /**
2831      * Fills in a whole hash. Non-string values are converted to string, using the standard (string) cast.
2832      * NULL values are stored as empty strings
2833      *
2834      * @param   string  $key
2835      * @param   array   $hashKeys key → value array
2836      * @return  bool
2837      * @link    http://redis.io/commands/hmset
2838      * @example
2839      * <pre>
2840      * $redis->delete('user:1');
2841      * $redis->hMset('user:1', array('name' => 'Joe', 'salary' => 2000));
2842      * $redis->hIncrBy('user:1', 'salary', 100); // Joe earns 100 more now.
2843      * </pre>
2844      */
2845     public function hMset( $key, $hashKeys ) {}
2846 
2847     /**
2848      * Retirieve the values associated to the specified fields in the hash.
2849      *
2850      * @param   string  $key
2851      * @param   array   $hashKeys
2852      * @return  array   Array An array of elements, the values of the specified fields in the hash,
2853      * with the hash keys as array keys.
2854      * @link    http://redis.io/commands/hmget
2855      * @example
2856      * <pre>
2857      * $redis->delete('h');
2858      * $redis->hSet('h', 'field1', 'value1');
2859      * $redis->hSet('h', 'field2', 'value2');
2860      * $redis->hmGet('h', array('field1', 'field2')); // returns array('field1' => 'value1', 'field2' => 'value2')
2861      * </pre>
2862      */
2863     public function hMGet( $key, $hashKeys ) {}
2864 
2865     /**
2866      * Get or Set the redis config keys.
2867      *
2868      * @param   string  $operation  either `GET` or `SET`
2869      * @param   string  $key        for `SET`, glob-pattern for `GET`. See http://redis.io/commands/config-get for examples.
2870      * @param   string  $value      optional string (only for `SET`)
2871      * @return  array   Associative array for `GET`, key -> value
2872      * @link    http://redis.io/commands/config-get
2873      * @link    http://redis.io/commands/config-set
2874      * @example
2875      * <pre>
2876      * $redis->config("GET", "*max-*-entries*");
2877      * $redis->config("SET", "dir", "/var/run/redis/dumps/");
2878      * </pre>
2879      */
2880     public function config( $operation, $key, $value ) {}
2881 
2882     /**
2883      * @see eval()
2884      * @param string $script
2885      * @param array  $args
2886      * @param int    $numKeys
2887      */
2888     public function evaluate( $script, $args = array(), $numKeys = 0 ) {}
2889 
2890     /**
2891      * Evaluate a LUA script serverside, from the SHA1 hash of the script instead of the script itself.
2892      * In order to run this command Redis will have to have already loaded the script, either by running it or via
2893      * the SCRIPT LOAD command.
2894      * @param   string  $scriptSha
2895      * @param   array   $args
2896      * @param   int     $numKeys
2897      * @return  mixed. @see eval()
2898      * @see     eval()
2899      * @link    http://redis.io/commands/evalsha
2900      * @example
2901      * <pre>
2902      * $script = 'return 1';
2903      * $sha = $redis->script('load', $script);
2904      * $redis->evalSha($sha); // Returns 1
2905      * </pre>
2906      */
2907     public function evalSha( $scriptSha, $args = array(), $numKeys = 0 ) {}
2908 
2909     /**
2910      * @see evalSha()
2911      * @param string $scriptSha
2912      * @param array  $args
2913      * @param int    $numKeys
2914      */
2915     public function evaluateSha( $scriptSha, $args = array(), $numKeys = 0 ) {}
2916 
2917     /**
2918      * Execute the Redis SCRIPT command to perform various operations on the scripting subsystem.
2919      * @param   string  $command load | flush | kill | exists
2920      * @param   string  $script
2921      * @return  mixed
2922      * @link    http://redis.io/commands/script-load
2923      * @link    http://redis.io/commands/script-kill
2924      * @link    http://redis.io/commands/script-flush
2925      * @link    http://redis.io/commands/script-exists
2926      * @example
2927      * <pre>
2928      * $redis->script('load', $script);
2929      * $redis->script('flush');
2930      * $redis->script('kill');
2931      * $redis->script('exists', $script1, [$script2, $script3, ...]);
2932      * </pre>
2933      *
2934      * SCRIPT LOAD will return the SHA1 hash of the passed script on success, and FALSE on failure.
2935      * SCRIPT FLUSH should always return TRUE
2936      * SCRIPT KILL will return true if a script was able to be killed and false if not
2937      * SCRIPT EXISTS will return an array with TRUE or FALSE for each passed script
2938      */
2939     public function script( $command, $script ) {}
2940 
2941     /**
2942      * The last error message (if any)
2943      * @return  string  A string with the last returned script based error message, or NULL if there is no error
2944      * @example
2945      * <pre>
2946      * $redis->eval('this-is-not-lua');
2947      * $err = $redis->getLastError();
2948      * // "ERR Error compiling script (new function): user_script:1: '=' expected near '-'"
2949      * </pre>
2950      */
2951     public function getLastError() {}
2952 
2953     /**
2954      * Clear the last error message
2955      *
2956      * @return bool true
2957      * @example
2958      * <pre>
2959      * $redis->set('x', 'a');
2960      * $redis->incr('x');
2961      * $err = $redis->getLastError();
2962      * // "ERR value is not an integer or out of range"
2963      * $redis->clearLastError();
2964      * $err = $redis->getLastError();
2965      * // NULL
2966      * </pre>
2967      */
2968     public function clearLastError() {}
2969 
2970     /**
2971      * A utility method to prefix the value with the prefix setting for phpredis.
2972      * @param   $value  The value you wish to prefix
2973      * @return  string  If a prefix is set up, the value now prefixed.  If there is no prefix, the value will be returned unchanged.
2974      * @example
2975      * <pre>
2976      * $redis->setOption(Redis::OPT_PREFIX, 'my-prefix:');
2977      * $redis->_prefix('my-value'); // Will return 'my-prefix:my-value'
2978      * </pre>
2979      */
2980     public function _prefix( $value ) {}
2981 
2982     /**
2983      * A utility method to unserialize data with whatever serializer is set up.  If there is no serializer set, the
2984      * value will be returned unchanged.  If there is a serializer set up, and the data passed in is malformed, an
2985      * exception will be thrown. This can be useful if phpredis is serializing values, and you return something from
2986      * redis in a LUA script that is serialized.
2987      * @param   string  $value  The value to be unserialized
2988      * @return mixed
2989      * @example
2990      * <pre>
2991      * $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP);
2992      * $redis->_unserialize('a:3:{i:0;i:1;i:1;i:2;i:2;i:3;}'); // Will return Array(1,2,3)
2993      * </pre>
2994      */
2995     public function _unserialize( $value ) {}
2996 
2997     /**
2998      * Dump a key out of a redis database, the value of which can later be passed into redis using the RESTORE command.
2999      * The data that comes out of DUMP is a binary representation of the key as Redis stores it.
3000      * @param   string  $key
3001      * @return  string  The Redis encoded value of the key, or FALSE if the key doesn't exist
3002      * @link    http://redis.io/commands/dump
3003      * @example
3004      * <pre>
3005      * $redis->set('foo', 'bar');
3006      * $val = $redis->dump('foo'); // $val will be the Redis encoded key value
3007      * </pre>
3008      */
3009     public function dump( $key ) {}
3010 
3011     /**
3012      * Restore a key from the result of a DUMP operation.
3013      *
3014      * @param   string  $key    The key name
3015      * @param   int     $ttl    How long the key should live (if zero, no expire will be set on the key)
3016      * @param   string  $value  (binary).  The Redis encoded key value (from DUMP)
3017      * @return  bool
3018      * @link    http://redis.io/commands/restore
3019      * @example
3020      * <pre>
3021      * $redis->set('foo', 'bar');
3022      * $val = $redis->dump('foo');
3023      * $redis->restore('bar', 0, $val); // The key 'bar', will now be equal to the key 'foo'
3024      * </pre>
3025      */
3026     public function restore( $key, $ttl, $value ) {}
3027 
3028     /**
3029      * Migrates a key to a different Redis instance.
3030      *
3031      * @param   string  $host       The destination host
3032      * @param   int     $port       The TCP port to connect to.
3033      * @param   string  $key        The key to migrate.
3034      * @param   int     $db         The target DB.
3035      * @param   int     $timeout    The maximum amount of time given to this transfer.
3036      * @return  bool
3037      * @link    http://redis.io/commands/migrate
3038      * @example
3039      * <pre>
3040      * $redis->migrate('backup', 6379, 'foo', 0, 3600);
3041      * </pre>
3042      */
3043     public function migrate( $host, $port, $key, $db, $timeout ) {}
3044 
3045     /**
3046      * Return the current Redis server time.
3047      * @return  array If successfull, the time will come back as an associative array with element zero being the
3048      * unix timestamp, and element one being microseconds.
3049      * @link    http://redis.io/commands/time
3050      * <pre>
3051      * var_dump( $redis->time() );
3052      * // array(2) {
3053      * //   [0] => string(10) "1342364352"
3054      * //   [1] => string(6) "253002"
3055      * // }
3056      * </pre>
3057      */
3058     public function time() {}
3059 }
3060 
3061 class RedisException extends Exception {}
3062 
3063 class RedisArray {
3064     /**
3065      * Constructor
3066      *
3067      * @param   string  $name   Name of the redis array to create (required if using redis.ini to define array)
3068      * @param   array   $hosts  Array of hosts to construct the array with
3069      * @param   array   $opts   Array of options
3070      * @link    https://github.com/nicolasff/phpredis/blob/master/arrays.markdown
3071      */
3072     function __construct($name = '', array $hosts = NULL, array $opts = NULL) {}
3073 
3074     /**
3075      * @return  array   list of hosts for the selected array
3076      */
3077     public function _hosts() {}
3078 
3079     /**
3080      * @return  string  the name of the function used to extract key parts during consistent hashing
3081      */
3082     public function _function() {}
3083 
3084     /**
3085      * @param   string  key     The key for which you want to lookup the host
3086      * @return  string  the host to be used for a certain key
3087      */
3088     public function _target($key) {}
3089 
3090     /**
3091      * Use this function when a new node is added and keys need to be rehashed.
3092      */
3093     public function _rehash() {}
3094 }
View Code

 

点赞(0)

评论列表 共有 0 条评论

暂无评论
立即
投稿
发表
评论
返回
顶部