在 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 "; 137 * } 138 * echo "No more keys to scan! "; 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 "; 482 * echo "Channel: $chan "; 483 * echo "Payload: $msg "; 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 "; 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 }