hrustbb2
/
project_start
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity
project_start/phpstorm-stubs/redis/Redis.php

6285 lines
226 KiB
PHP
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

<?php
use JetBrains\PhpStorm\Deprecated;
/**
* Helper autocomplete for php redis extension
*
* @link https://github.com/phpredis/phpredis/blob/develop/redis.stub.php
*/
class Redis
{
public const AFTER = 'after';
public const BEFORE = 'before';
public const LEFT = 'left';
public const RIGHT = 'right';
/**
* Options
*/
public const OPT_SERIALIZER = 1;
public const OPT_PREFIX = 2;
public const OPT_READ_TIMEOUT = 3;
public const OPT_SCAN = 4;
public const OPT_FAILOVER = 5;
public const OPT_TCP_KEEPALIVE = 6;
public const OPT_COMPRESSION = 7;
public const OPT_REPLY_LITERAL = 8;
public const OPT_COMPRESSION_LEVEL = 9;
public const OPT_NULL_MULTIBULK_AS_NULL = 10;
public const OPT_MAX_RETRIES = 11;
public const OPT_BACKOFF_ALGORITHM = 12;
public const OPT_BACKOFF_BASE = 13;
public const OPT_BACKOFF_CAP = 14;
/**
* Cluster options
*/
public const FAILOVER_NONE = 0;
public const FAILOVER_ERROR = 1;
public const FAILOVER_DISTRIBUTE = 2;
public const FAILOVER_DISTRIBUTE_SLAVES = 3;
/**
* SCAN options
*/
public const SCAN_NORETRY = 0;
public const SCAN_RETRY = 1;
/**
* @since 5.3.0
*/
public const SCAN_PREFIX = 2;
/**
* @since 5.3.0
*/
public const SCAN_NOPREFIX = 3;
/**
* Serializers
*/
public const SERIALIZER_NONE = 0;
public const SERIALIZER_PHP = 1;
public const SERIALIZER_IGBINARY = 2;
public const SERIALIZER_MSGPACK = 3;
public const SERIALIZER_JSON = 4;
/**
* Compressions
*/
public const COMPRESSION_NONE = 0;
public const COMPRESSION_LZF = 1;
public const COMPRESSION_ZSTD = 2;
public const COMPRESSION_LZ4 = 3;
/**
* Compression ZSTD levels
*/
public const COMPRESSION_ZSTD_MIN = 1;
public const COMPRESSION_ZSTD_DEFAULT = 3;
public const COMPRESSION_ZSTD_MAX = 22;
/**
* Multi
*/
public const ATOMIC = 0;
public const MULTI = 1;
public const PIPELINE = 2;
/**
* Types
*/
public const REDIS_NOT_FOUND = 0;
public const REDIS_STRING = 1;
public const REDIS_SET = 2;
public const REDIS_LIST = 3;
public const REDIS_ZSET = 4;
public const REDIS_HASH = 5;
public const REDIS_STREAM = 6;
/**
* Backoff algorithms
* @since 5.3.5
*/
public const BACKOFF_ALGORITHM_DEFAULT = 0;
public const BACKOFF_ALGORITHM_DECORRELATED_JITTER = 1;
public const BACKOFF_ALGORITHM_FULL_JITTER = 2;
public const BACKOFF_ALGORITHM_EQUAL_JITTER = 3;
public const BACKOFF_ALGORITHM_EXPONENTIAL = 4;
public const BACKOFF_ALGORITHM_UNIFORM = 5;
public const BACKOFF_ALGORITHM_CONSTANT = 6;
/**
* Creates a Redis client
*
* @param array|null $options configuration options
*
* @example
*
* $redis = new Redis();
*
* // Starting from version 6.0.0 it's possible to specify configuration options.
* // This allows to connect to the server without explicitly invoking connect command.
* $redis = new Redis([
* // If you do wish to connect via the constructor, only 'host' is strictly required,
* // which will cause PhpRedis to connect to that host on Redis' default port (6379).
* 'host' => '127.0.0.1',
* 'port' => 6379,
* 'readTimeout' => 2.5,
* 'connectTimeout' => 2.5,
* 'persistent' => true,
* // Valid formats: NULL, ['user', 'pass'], 'pass', or ['pass']
* 'auth' => ['phpredis', 'phpredis'],
* // See PHP stream options for valid SSL configuration settings.
* 'ssl' => ['verify_peer' => false],
* // How quickly to retry a connection after we time out or it closes.
* // Note that this setting is overridden by 'backoff' strategies.
* 'retryInterval' => 100,
* // Which backoff algorithm to use. 'decorrelated jitter' is likely the
* // bestone for most solution, but there are many to choose from
* 'backoff' => [
* 'algorithm' => Redis::BACKOFF_ALGORITHM_DECORRELATED_JITTER,
* // 'base', and 'cap' are in milliseconds and represent the first delay redis will
* // use when reconnecting, and the maximum delay we will reach while retrying.
* 'base' => 500,
* 'cap' => 750,
* ],
* ]);
*/
public function __construct($options = null) {}
/**
* Connects to a Redis instance.
*
* @param string $host can be a host, or the path to a unix domain socket
* @param int $port optional
* @param float $timeout value in seconds (optional, default is 0.0 meaning it will use `default_socket_timeout`)
* @param string|null $persistent_id identity for the requested persistent connection
* @param int $retry_interval retry interval in milliseconds.
* @param float $read_timeout value in seconds (optional, default is 0 meaning it will use `default_socket_timeout`)
* @param array|null $context since PhpRedis >= 5.3.0 can specify authentication and stream information on connect
*
* @return bool TRUE on success, FALSE on error
*
* @throws RedisException
*
* @example
* <pre>
* $redis->connect('127.0.0.1', 6379);
* $redis->connect('127.0.0.1'); // port 6379 by default
* $redis->connect('127.0.0.1', 6379, 2.5); // 2.5 sec timeout.
* $redis->connect('/tmp/redis.sock'); // unix domain socket.
* // since PhpRedis >= 5.3.0 can specify authentication and stream information on connect
* $redis->connect('127.0.0.1', 6379, 1, NULL, 0, 0, ['auth' => ['phpredis', 'phpredis']]);
* </pre>
*/
public function connect(
$host,
$port = 6379,
$timeout = 0,
$persistent_id = null,
$retry_interval = 0,
$read_timeout = 0,
$context = null
) {}
/**
* Connects to a Redis instance.
*
* @param string $host can be a host, or the path to a unix domain socket
* @param int $port optional
* @param float $timeout value in seconds (optional, default is 0.0 meaning it will use `default_socket_timeout`)
* @param string $persistent_id identity for the requested persistent connection
* @param int $retry_interval retry interval in milliseconds.
* @param float $read_timeout value in seconds (optional, default is 0 meaning it will use `default_socket_timeout`)
* @param array $context since PhpRedis >= 5.3.0 can specify authentication and stream information on connect
*
* @return bool TRUE on success, FALSE on error
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->connect(%parametersList%)')]
public function open(
$host,
$port = 6379,
$timeout = 0,
$persistent_id = null,
$retry_interval = 0,
$read_timeout = 0,
$context = null
) {}
/**
* A method to determine if a phpredis object thinks it's connected to a server
*
* @return bool Returns TRUE if phpredis thinks it's connected and FALSE if not
*
* @throws RedisException
*/
public function isConnected() {}
/**
* Retrieve our host or unix socket that we're connected to
*
* @return string|false The host or unix socket we're connected to or FALSE if we're not connected
*
* @throws RedisException
*/
public function getHost() {}
/**
* Get the port we're connected to
*
* This number will be zero if we are connected to a unix socket.
*
* @return int|false Returns the port we're connected to or FALSE if we're not connected
*
* @throws RedisException
*/
public function getPort() {}
/**
* Get the database number phpredis is pointed to
*
* @return int|bool Returns the database number (int) phpredis thinks it's pointing to
* or FALSE if we're not connected
*
* @throws RedisException
*/
public function getDbNum() {}
/**
* Get the (write) timeout in use for phpredis
*
* @return float|false The timeout (DOUBLE) specified in our connect call or FALSE if we're not connected
*
* @throws RedisException
*/
public function getTimeout() {}
/**
* Get the read timeout specified to phpredis or FALSE if we're not connected
*
* @return float|bool Returns the read timeout (which can be set using setOption and Redis::OPT_READ_TIMEOUT)
* or FALSE if we're not connected
*
* @throws RedisException
*/
public function getReadTimeout() {}
/**
* Gets the persistent ID that phpredis is using
*
* @return string|null|bool Returns the persistent id phpredis is using
* (which will only be set if connected with pconnect),
* NULL if we're not using a persistent ID,
* and FALSE if we're not connected
*
* @throws RedisException
*/
public function getPersistentID() {}
/**
* Get the authentication information on the connection, if any.
*
* @return mixed The authentication information used to authenticate the connection.
*
* @throws RedisException
*/
public function getAuth() {}
/**
* Connects to a Redis instance or reuse a connection already established with pconnect/popen.
*
* The connection will not be closed on close or end of request until the php process ends.
* So be patient on to many open FD's (specially on redis server side) when using persistent connections on
* many servers connecting to one redis server.
*
* Also more than one persistent connection can be made identified by either host + port + timeout
* or host + persistentId or unix socket + timeout.
*
* This feature is not available in threaded versions. pconnect and popen then working like their non persistent
* equivalents.
*
* @param string $host can be a host, or the path to a unix domain socket
* @param int $port optional
* @param float $timeout value in seconds (optional, default is 0.0 meaning it will use `default_socket_timeout`)
* @param string|null $persistent_id identity for the requested persistent connection
* @param int $retry_interval retry interval in milliseconds.
* @param float $read_timeout value in seconds (optional, default is 0 meaning it will use `default_socket_timeout`)
* @param array|null $context since PhpRedis >= 5.3.0 can specify authentication and stream information on connect
*
* @return bool TRUE on success, FALSE on error.
*
* @throws RedisException
*
* @example
* <pre>
* $redis->pconnect('127.0.0.1', 6379);
*
* // port 6379 by default - same connection like before
* $redis->pconnect('127.0.0.1');
*
* // 2.5 sec timeout and would be another connection than the two before.
* $redis->pconnect('127.0.0.1', 6379, 2.5);
*
* // x is sent as persistent_id and would be another connection than the three before.
* $redis->pconnect('127.0.0.1', 6379, 2.5, 'x');
*
* // unix domain socket - would be another connection than the four before.
* $redis->pconnect('/tmp/redis.sock');
* </pre>
*/
public function pconnect(
$host,
$port = 6379,
$timeout = 0,
$persistent_id = null,
$retry_interval = 0,
$read_timeout = 0,
$context = null
) {}
/**
* @param string $host
* @param int $port
* @param float $timeout
* @param string|null $persistent_id
* @param int $retry_interval
* @param float $read_timeout
* @param array|null $context
*
* @return bool
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->pconnect(%parametersList%)')]
public function popen(
$host,
$port = 6379,
$timeout = 0,
$persistent_id = null,
$retry_interval = 0,
$read_timeout = 0,
$context = null
) {}
/**
* Disconnects from the Redis instance.
*
* Note: Closing a persistent connection requires PhpRedis >= 4.2.0
*
* @since >= 4.2 Closing a persistent connection requires PhpRedis
*
* @return bool TRUE on success, FALSE on error
*
* @throws RedisException
*/
public function close() {}
/**
* Swap one Redis database with another atomically
*
* Note: Requires Redis >= 4.0.0
*
* @param int $db1
* @param int $db2
*
* @return bool TRUE on success and FALSE on failure
*
* @throws RedisException
*
* @link https://redis.io/commands/swapdb
* @since >= 4.0
* @example
* <pre>
* // Swaps DB 0 with DB 1 atomically
* $redis->swapdb(0, 1);
* </pre>
*/
public function swapdb(int $db1, int $db2) {}
/**
* Set a configurable option on the Redis object.
*
* @param int $option The option constant.
* @param mixed $value The option value.
*
* @return bool TRUE on success, FALSE on error
*
* @throws RedisException
*
* @example
* <pre>
* $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE); // don't serialize data
* $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP); // use built-in serialize/unserialize
* $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_IGBINARY); // use igBinary serialize/unserialize
* $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_MSGPACK); // Use msgpack serialize/unserialize
* $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_JSON); // Use json serialize/unserialize
*
* $redis->setOption(Redis::OPT_PREFIX, 'myAppName:'); // use custom prefix on all keys
*
* // Options for the SCAN family of commands, indicating whether to abstract
* // empty results from the user. If set to SCAN_NORETRY (the default), phpredis
* // will just issue one SCAN command at a time, sometimes returning an empty
* // array of results. If set to SCAN_RETRY, phpredis will retry the scan command
* // until keys come back OR Redis returns an iterator of zero
* $redis->setOption(Redis::OPT_SCAN, Redis::SCAN_NORETRY);
* $redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
* </pre>
*/
public function setOption($option, $value) {}
/**
* Retrieve the value of a configuration setting as set by Redis::setOption()
*
* @param int $option parameter name
*
* @return mixed|null The setting itself or false on failure.
*
* @throws RedisException
*
* @see setOption()
* @example
* // return option value
* $redis->getOption(Redis::OPT_SERIALIZER);
*/
public function getOption($option) {}
/**
* Check the current connection status
*
* @param string $message An optional string message that Redis will reply with, if passed.
*
* @return bool|string TRUE if the command is successful or returns message
* Throws a RedisException object on connectivity error, as described above.
* @throws RedisException
* @link https://redis.io/commands/ping
*
* @example
* // When called without an argument, PING returns `TRUE`
* $redis->ping();
*
* // If passed an argument, that argument is returned. Here 'hello' will be returned
* $redis->ping('hello');
*/
public function ping($message = null) {}
/**
* Sends a string to Redis, which replies with the same string
*
* @param string $message
*
* @return string|Redis The string sent to Redis or false on failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/echo
*
* @example $redis->echo('Hello, World');
*/
public function echo($message) {}
/**
* Get the value related to the specified key
*
* @param string $key
*
* @return string|mixed|false|Redis If key didn't exist, FALSE is returned or Redis if in multimode
* Otherwise, the value related to this key is returned
*
* @throws RedisException
*
* @link https://redis.io/commands/get
* @example
* <pre>
* $redis->set('key', 'hello');
* $redis->get('key');
*
* // set and get with serializer
* $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_JSON);
*
* $redis->set('key', ['asd' => 'as', 'dd' => 123, 'b' => true]);
* var_dump($redis->get('key'));
* // Output:
* array(3) {
* 'asd' => string(2) "as"
* 'dd' => int(123)
* 'b' => bool(true)
* }
* </pre>
*/
public function get($key) {}
/**
* Set the string value in argument as value of the key.
*
* @since If you're using Redis >= 2.6.12, you can pass extended options as explained in example
*
* @param string $key The key name to set.
* @param mixed $value The value to set the key to.
* @param mixed $options Either an array with options for how to perform the set or an integer with an expiration.
* If an expiration is set PhpRedis will actually send the `SETEX` command.
* Since 2.6.12 it also supports different flags inside an array.
* OPTION DESCRIPTION
* ------------ --------------------------------------------------------------
* ['EX' => 60] expire 60 seconds.
* ['PX' => 6000] expire in 6000 milliseconds.
* ['EXAT' => time() + 10] expire in 10 seconds.
* ['PXAT' => time()*1000 + 1000] expire in 1 second.
* ['KEEPTTL' => true] Redis will not update the key's current TTL.
* ['XX'] Only set the key if it already exists.
* ['NX'] Only set the key if it doesn't exist.
* ['GET'] Instead of returning `+OK` return the previous value of the
* key or NULL if the key didn't exist.
*
* @example
* <pre>
* // Simple key -> value set
* $redis->set('key', 'value');
*
* // Will redirect, and actually make an SETEX call
* $redis->set('key','value', 10);
*
* // Will set the key, if it doesn't exist, with a ttl of 10 seconds
* $redis->set('key', 'value', ['nx', 'ex' => 10]);
*
* // Will set a key, if it does exist, with a ttl of 1000 milliseconds
* $redis->set('key', 'value', ['xx', 'px' => 1000]);
* </pre>
*
* @return bool|Redis TRUE if the command is successful or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/set
*/
public function set($key, $value, $options = null) {}
/**
* Set the string value in argument as value of the key, with a time to live.
*
* @param string $key The name of the key to set.
* @param int $expire The key's expiration in seconds.
* @param mixed $value The value to set the key.
*
* @return bool|Redis returns Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/setex
* @example $redis->setex('key', 3600, 'value'); // sets key → value, with 1h TTL.
*/
public function setex($key, $expire, $value) {}
/**
* Set the value and expiration in milliseconds of a key.
*
* @see setex()
* @param string $key The key to set
* @param int $expire The TTL to set, in milliseconds.
* @param mixed $value The value to set the key to.
*
* @return bool|Redis returns Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/psetex
* @example $redis->psetex('key', 1000, 'value'); // sets key → value, with 1sec TTL.
*/
public function psetex($key, $expire, $value) {}
/**
* Set the string value in argument as value of the key if the key doesn't already exist in the database.
*
* @param string $key
* @param mixed $value
*
* @return bool|array|Redis returns Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/setnx
* @example
* <pre>
* $redis->setnx('key', 'value'); // return TRUE
* $redis->setnx('key', 'value'); // return FALSE
* </pre>
*/
public function setnx(string $key, $value) {}
/**
* Remove specified keys.
*
* @param string|array $key1 Either an array with one or more key names or a string with the name of a key.
* @param string ...$otherKeys One or more additional keys passed in a variadic fashion.
*
* @return false|int|Redis Number of keys deleted or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/del
* @example
* <pre>
* $redis->set('key1', 'val1');
* $redis->set('key2', 'val2');
* $redis->set('key3', 'val3');
* $redis->set('key4', 'val4');
*
* $redis->del('key1', 'key2'); // return 2
* $redis->del(['key3', 'key4']); // return 2
* </pre>
*/
public function del($key1, ...$otherKeys) {}
/**
* Remove specified keys.
*
* @param string|array $key An array of keys, or an undefined number of parameters, each a key: key1 key2 key3 ... keyN
* @param string ...$otherKeys
*
* @return false|int|Redis Number of keys deleted or Redis if in multimode
*
* @throws RedisException
*/
#[Deprecated(replacement: "%class%->del(%parametersList%)")]
public function delete($key, ...$otherKeys) {}
/**
* Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
*
* @see del()
* @param string|array $key An array of keys, or an undefined number of parameters, each a key: key1 key2 key3 ... keyN
* @param string ...$other_keys
*
* @return false|int|Redis Number of keys unlinked or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/unlink
* @example
* <pre>
* $redis->set('key1', 'val1');
* $redis->set('key2', 'val2');
* $redis->set('key3', 'val3');
* $redis->set('key4', 'val4');
* $redis->unlink('key1', 'key2'); // return 2
* $redis->unlink(array('key3', 'key4')); // return 2
* </pre>
*/
public function unlink($key, ...$other_keys) {}
/**
* Enter and exit transactional mode.
*
* @param int $mode Redis::MULTI|Redis::PIPELINE
* Defaults to Redis::MULTI.
* A Redis::MULTI block of commands runs as a single transaction;
* a Redis::PIPELINE block is simply transmitted faster to the server, but without any guarantee of atomicity.
* discard cancels a transaction.
*
* @return static|Redis returns the Redis instance and enters multi-mode or Redis if in multimode
* Once in multi-mode, all subsequent method calls return the same object until exec() is called.
*
* @throws RedisException
*
* @link https://redis.io/commands/multi
* @example
* <pre>
* $ret = $redis->multi()
* ->set('key1', 'val1')
* ->get('key1')
* ->set('key2', 'val2')
* ->get('key2')
* ->exec();
*
* //$ret == array (
* // 0 => TRUE,
* // 1 => 'val1',
* // 2 => TRUE,
* // 3 => 'val2');
* </pre>
*/
public function multi($mode = Redis::MULTI) {}
/**
* Returns a Redis instance which can simply transmitted faster to the server.
*
* @return bool|Redis returns the Redis instance.
* Once in pipeline-mode, all subsequent method calls return the same object until exec() is called.
* Pay attention, that Pipeline is not a transaction, so you can get unexpected
* results in case of big pipelines and small read/write timeouts.
*
* @throws RedisException
*
* @link https://redis.io/topics/pipelining
* @example
* <pre>
* $ret = $this->redis->pipeline()
* ->ping()
* ->multi()->set('x', 42)->incr('x')->exec()
* ->ping()
* ->multi()->get('x')->del('x')->exec()
* ->ping()
* ->exec();
*
* //$ret == array (
* // 0 => '+PONG',
* // 1 => [TRUE, 43],
* // 2 => '+PONG',
* // 3 => [43, 1],
* // 4 => '+PONG');
* </pre>
*/
public function pipeline() {}
/**
* Execute either a MULTI or PIPELINE block and return the array of replies.
*
* @return array|false|Redis The array of pipeline'd or multi replies or false on failure or Redis if in multimode
*
* @throws RedisException
*
* @see multi()
* @link https://redis.io/commands/exec
* @link https://redis.io/commands/multi
*
* @example
* $res = $redis->multi()
* ->set('foo', 'bar')
* ->get('foo')
* ->del('list')
* ->rpush('list', 'one', 'two', 'three')
* ->exec();
*/
public function exec() {}
/**
* Flushes all previously queued commands in a transaction and restores the connection state to normal.
*
* @return bool|Redis True if we could discard the transaction or Redis if in multimode
*
* @throws RedisException
*
* @see multi()
* @link https://redis.io/commands/discard
*
* @example
* $redis->getMode();
* $redis->set('foo', 'bar');
* $redis->discard();
* $redis->getMode();
*/
public function discard() {}
/**
* Watches a key for modifications by another client. If the key is modified between WATCH and EXEC,
* the MULTI/EXEC transaction will fail (return FALSE). unwatch cancels all the watching of all keys by this client.
*
* @param string|array $key Either an array with one or more key names, or a string key name
* @param string ...$other_keys If the first argument was passed as a string, any number of
* additional string key names may be passed variadically.
*
* @return bool|Redis returns Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/watch
* @example
* <pre>
* $redis->watch('x');
* // long code here during the execution of which other clients could well modify `x`
* $ret = $redis->multi()
* ->incr('x')
* ->exec();
* // $ret = FALSE if x has been modified between the call to WATCH and the call to EXEC.
* </pre>
*/
public function watch($key, ...$other_keys) {}
/**
* Remove any previously WATCH'ed keys in a transaction.
*
* @throws RedisException
*
* @see watch()
* @return bool|Redis
* @link https://redis.io/commands/unwatch
*/
public function unwatch() {}
/**
* Subscribes the client to the specified channels.
*
* Once the client enters the subscribed state it is not supposed to issue any other commands, except for additional SUBSCRIBE, SSUBSCRIBE, PSUBSCRIBE, UNSUBSCRIBE, SUNSUBSCRIBE, PUNSUBSCRIBE, PING, RESET and QUIT commands.
*
* @param array|string $channels One or more channel names.
* @param callable $callback The callback PhpRedis will invoke when we receive a message from one of the subscribed channels.
*
* @return false|array|Redis False on faiilure. Note that this command will block the client in a subscribe loop, waiting for messages to arrive
*
* @throws RedisException
*
* @link https://redis.io/commands/subscribe
* @since 2.0
*
* @example
* $redis->subscribe(['channel-1', 'channel-2'], function ($redis, $channel, $message) {
* echo "[$channel]: $message\n";
*
* // Unsubscribe from the message channel when we read 'quit'
* if ($message == 'quit') {
* echo "Unsubscribing from '$channel'\n";
* $redis->unsubscribe([$channel]);
* }
* });
*
* // Once we read 'quit' from both channel-1 and channel-2 the subscribe loop will be broken and this command will execute.
* echo "Subscribe loop ended\n";
*/
public function subscribe($channels, $callback) {}
/**
* Subscribe to channels by pattern
*
* @param array $patterns an array of glob-style patterns to subscribe
* @param string|array|callable $callback Either a string or an array with an object and method.
* The callback will get four arguments ($redis, $pattern, $channel, $message)
* @return mixed|Redis Any non-null return value in the callback will be returned to the caller or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/psubscribe
* @example
* <pre>
* function f($redis, $pattern, $chan, $msg) {
* echo "Pattern: $pattern\n";
* echo "Channel: $chan\n";
* echo "Payload: $msg\n";
* }
*
* $redis->psubscribe(array('chan-1', 'chan-2', 'chan-3'), 'f')
* </pre>
*/
public function psubscribe($patterns, $callback) {}
/**
* Publish messages to channels.
*
* Warning: this function will probably change in the future.
*
* @param string $channel The channel to publish to.
* @param string $message The message itself.
*
* @return false|int|Redis Number of clients that received the message or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/publish
* @example $redis->publish('chan-1', 'hello, world!'); // send message.
*/
public function publish($channel, $message) {}
/**
* A command allowing you to get information on the Redis pub/sub system
*
* @param string $keyword String, which can be: "channels", "numsub", or "numpat"
* @param mixed $argument Optional, variant.
* For the "channels" subcommand, you can pass a string pattern.
* For "numsub" an array of channel names
*
* @return mixed|Redis Either an integer or an array or Redis if in multimode
* - channels Returns an array where the members are the matching channels.
* - numsub Returns a key/value array where the keys are channel names and
* values are their counts.
* - numpat Integer return containing the number active pattern subscriptions
*
* @throws RedisException
*
* @link https://redis.io/commands/pubsub
* @example
* <pre>
* $redis->pubsub('channels'); // All channels
* $redis->pubsub('channels', '*pattern*'); // Just channels matching your pattern
* $redis->pubsub('numsub', array('chan1', 'chan2')); // Get subscriber counts for 'chan1' and 'chan2'
* $redis->pubsub('numpat'); // Get the number of pattern subscribers
* </pre>
*/
public function pubsub($keyword, $argument = null) {}
/**
* Stop listening for messages posted to the given channels.
*
* @param array $channels One or more channels to unsubscribe from.
*
* @return bool|array|Redis The array of unsubscribed channels.
*
* @throws RedisException
*
* @link https://redis.io/commands/unsubscribe
*
* @example
* $redis->subscribe(['channel-1', 'channel-2'], function ($redis, $channel, $message) {
* if ($message == 'quit') {
* echo "$channel => 'quit' detected, unsubscribing!\n";
* $redis->unsubscribe([$channel]);
* } else {
* echo "$channel => $message\n";
* }
* });
*/
public function unsubscribe(array $channels) {}
/**
* Stop listening for messages posted to the given channels.
*
* @param array $patterns an array of glob-style patterns to unsubscribe
*
* @return false|array
*
* @throws RedisException
*
* @link https://redis.io/commands/punsubscribe
*/
public function punsubscribe(array $patterns) {}
/**
* Verify if the specified key/keys exists
*
* This function took a single argument and returned TRUE or FALSE in phpredis versions < 4.0.0.
*
* @since >= 4.0 Returned int, if < 4.0 returned bool
*
* @param mixed $key Either an array of keys or a string key
* @param mixed ...$other_keys If the previous argument was a string, you may send any number of additional keys to test.
*
* @return int|bool|Redis The number of keys tested that do exist or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/exists
* @link https://github.com/phpredis/phpredis#exists
* @example
* <pre>
* $redis->exists('key'); // 1
* $redis->exists('NonExistingKey'); // 0
*
* $redis->mset(['foo' => 'foo', 'bar' => 'bar', 'baz' => 'baz']);
* $redis->exists(['foo', 'bar', 'baz]); // 3
* $redis->exists('foo', 'bar', 'baz'); // 3
* </pre>
*/
public function exists($key, ...$other_keys) {}
/**
* Increment the number stored at key by one.
*
* @param string $key The key to increment
* @param int $by An optional amount to increment by.
*
* @return false|int|Redis the new value or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/incr
* @example
* <pre>
* $redis->incr('key1'); // key1 didn't exists, set to 0 before the increment and now has the value 1
* $redis->incr('key1'); // 2
* $redis->incr('key1'); // 3
* $redis->incr('key1'); // 4
* $redis->incr('key1', 2); // 6
* </pre>
*/
public function incr($key, $by = 1) {}
/**
* Increment the float value of a key by the given amount
*
* @param string $key
* @param float $increment
*
* @return float|false|Redis returns Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/incrbyfloat
* @example
* <pre>
* $redis->set('x', 3);
* $redis->incrByFloat('x', 1.5); // float(4.5)
* $redis->get('x'); // float(4.5)
* $redis->incrByFloat('x', 3.1415926);
* </pre>
*/
public function incrByFloat($key, $increment) {}
/**
* Increment the number stored at key by one.
*
* @param string $key The key to increment.
* @param int $value The amount to increment.
*
* @return false|int|Redis the new value or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/incrby
* @example
* <pre>
* $redis->incr('key1'); // key1 didn't exists, set to 0 before the increment and now has the value 1
* $redis->incr('key1'); // 2
* $redis->incr('key1'); // 3
* $redis->incr('key1'); // 4
* $redis->incrBy('key1', 10); // 14
* </pre>
*/
public function incrBy($key, $value) {}
/**
* Decrement the number stored at key by one.
*
* @param string $key The key to decrement
* @param int $by How much to decrement the key. Note that if this value is not sent or is set to `1`
*
* @return false|int|Redis The new value of the key or false on failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/decr
* @example
* <pre>
* $redis->decr('key1'); // key1 didn't exists, set to 0 before the increment and now has the value -1
* $redis->decr('key1'); // -2
* $redis->decr('key1'); // -3
* $redis->decr('key1', 2); // -5
* </pre>
*/
public function decr($key, $by = 1) {}
/**
* Decrement the number stored at key by one.
*
* @param string $key The integer key to decrement.
* @param int $value How much to decrement the key.
*
* @return false|int|Redis The new value of the key or false on failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/decrby
* @example
* <pre>
* $redis->decr('key1'); // key1 didn't exists, set to 0 before the increment and now has the value -1
* $redis->decr('key1'); // -2
* $redis->decr('key1'); // -3
* $redis->decrBy('key1', 10); // -13
* </pre>
*/
public function decrBy($key, $value) {}
/**
* Adds the string values to the head (left) of the list.
* Creates the list if the key didn't exist.
* If the key exists and is not a list, FALSE is returned.
*
* @param string $key The list to prepend.
* @param mixed ...$value1 One or more elements to prepend.
*
* @return int|false|Redis The new length of the list in case of success, FALSE in case of Failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/lpush
* @example
* <pre>
* $redis->lPush('l', 'v1', 'v2', 'v3', 'v4') // int(4)
* var_dump( $redis->lRange('l', 0, -1) );
* // Output:
* // array(4) {
* // [0]=> string(2) "v4"
* // [1]=> string(2) "v3"
* // [2]=> string(2) "v2"
* // [3]=> string(2) "v1"
* // }
* </pre>
*/
public function lPush($key, ...$value1) {}
/**
* Adds the string values to the tail (right) of the list.
* Creates the list if the key didn't exist.
* If the key exists and is not a list, FALSE is returned.
*
* @param string $key The list to append to.
* @param mixed ...$value1 one or more elements to append.
*
* @return int|false|Redis The new length of the list in case of success, FALSE in case of Failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/rpush
* @example
* <pre>
* $redis->rPush('l', 'v1', 'v2', 'v3', 'v4'); // int(4)
* var_dump( $redis->lRange('l', 0, -1) );
* // Output:
* // array(4) {
* // [0]=> string(2) "v1"
* // [1]=> string(2) "v2"
* // [2]=> string(2) "v3"
* // [3]=> string(2) "v4"
* // }
* </pre>
*/
public function rPush($key, ...$value1) {}
/**
* Adds the string value to the head (left) of the list if the list exists.
*
* @param string $key The key to prepend to.
* @param mixed $value The value to prepend.
*
* @return int|false|Redis The new length of the list in case of success, FALSE in case of Failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/lpushx
* @example
* <pre>
* $redis->del('key1');
* $redis->lPushx('key1', 'A'); // returns 0
* $redis->lPush('key1', 'A'); // returns 1
* $redis->lPushx('key1', 'B'); // returns 2
* $redis->lPushx('key1', 'C'); // returns 3
* // key1 now points to the following list: [ 'A', 'B', 'C' ]
* </pre>
*/
public function lPushx($key, $value) {}
/**
* Adds the string value to the tail (right) of the list if the ist exists. FALSE in case of Failure.
*
* @param string $key The key to prepend to.
* @param mixed $value The value to prepend.
*
* @return int|false|Redis The new length of the list in case of success, FALSE in case of Failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/rpushx
* @example
* <pre>
* $redis->del('key1');
* $redis->rPushx('key1', 'A'); // returns 0
* $redis->rPush('key1', 'A'); // returns 1
* $redis->rPushx('key1', 'B'); // returns 2
* $redis->rPushx('key1', 'C'); // returns 3
* // key1 now points to the following list: [ 'A', 'B', 'C' ]
* </pre>
*/
public function rPushx($key, $value) {}
/**
* Returns and removes the first element of the list.
*
* @param string $key The list to pop from.
* @param int $count Optional number of elements to remove. By default one element is popped.
*
* @return mixed|bool|Redis if command executed successfully BOOL FALSE in case of failure (empty list) or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/lpop
* @example
* <pre>
* $redis->rPush('key1', 'A');
* $redis->rPush('key1', 'B');
* $redis->rPush('key1', 'C'); // key1 => [ 'A', 'B', 'C' ]
* $redis->lPop('key1'); // key1 => [ 'B', 'C' ]
* </pre>
*/
public function lPop($key, $count = 0) {}
/**
* Returns and removes the last element of the list.
*
* @param string $key A redis LIST key name.
* @param int $count The maximum number of elements to pop at once. NOTE: The `count` argument requires Redis >= 6.2.0
*
* @return mixed|array|string|bool|Redis if command executed successfully BOOL FALSE in case of failure (empty list) or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/rpop
* @example
* <pre>
* $redis->rPush('key1', 'A');
* $redis->rPush('key1', 'B');
* $redis->rPush('key1', 'C'); // key1 => [ 'A', 'B', 'C' ]
* $redis->rPop('key1'); // key1 => [ 'A', 'B' ]
* </pre>
*/
public function rPop($key, $count = 0) {}
/**
* Is a blocking lPop primitive. If at least one of the lists contains at least one element,
* the element will be popped from the head of the list and returned to the caller.
* Il all the list identified by the keys passed in arguments are empty, blPop will block
* during the specified timeout until an element is pushed to one of those lists. This element will be popped.
*
* @param string|string[] $key_or_keys String array containing the keys of the lists OR variadic list of strings
* @param string|float|int $timeout_or_key Timeout is always the required final parameter
* @param mixed ...$extra_args
*
* @return array|null|false|Redis Can return various things depending on command and data or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/blpop
* @example
* <pre>
* // Non blocking feature
* $redis->lPush('key1', 'A');
* $redis->del('key2');
*
* $redis->blPop('key1', 'key2', 10); // array('key1', 'A')
* // OR
* $redis->blPop(['key1', 'key2'], 10); // array('key1', 'A')
*
* $redis->blPop('key1', 'key2', 10); // array('key1', 'A')
* // OR
* $redis->blPop(['key1', 'key2'], 10); // array('key1', 'A')
*
* // Blocking feature
*
* // process 1
* $redis->del('key1');
* $redis->blPop('key1', 10);
* // blocking for 10 seconds
*
* // process 2
* $redis->lPush('key1', 'A');
*
* // process 1
* // array('key1', 'A') is returned
* </pre>
*/
public function blPop($key_or_keys, $timeout_or_key, ...$extra_args) {}
/**
* Is a blocking rPop primitive. If at least one of the lists contains at least one element,
* the element will be popped from the head of the list and returned to the caller.
* Il all the list identified by the keys passed in arguments are empty, brPop will
* block during the specified timeout until an element is pushed to one of those lists.
* This element will be popped.
*
* @param string|string[] $key_or_keys String array containing the keys of the lists OR variadic list of strings
* @param string|float|int $timeout_or_key Timeout is always the required final parameter
* @param mixed ...$extra_args
*
* @return array|null|true|Redis Can return various things depending on command and data or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/brpop
* @example
* <pre>
* // Non blocking feature
* $redis->rPush('key1', 'A');
* $redis->del('key2');
*
* $redis->brPop('key1', 'key2', 10); // array('key1', 'A')
* // OR
* $redis->brPop(array('key1', 'key2'), 10); // array('key1', 'A')
*
* $redis->brPop('key1', 'key2', 10); // array('key1', 'A')
* // OR
* $redis->brPop(array('key1', 'key2'), 10); // array('key1', 'A')
*
* // Blocking feature
*
* // process 1
* $redis->del('key1');
* $redis->brPop('key1', 10);
* // blocking for 10 seconds
*
* // process 2
* $redis->lPush('key1', 'A');
*
* // process 1
* // array('key1', 'A') is returned
* </pre>
*/
public function brPop($key_or_keys, $timeout_or_key, ...$extra_args) {}
/**
* Returns the size of a list identified by Key. If the list didn't exist or is empty,
* the command returns 0. If the data type identified by Key is not a list, the command return FALSE.
*
* @param string $key
*
* @return int|bool|Redis The size of the list identified by Key exists or Redis if in multimode
* bool FALSE if the data type identified by Key is not list
*
* @throws RedisException
*
* @link https://redis.io/commands/llen
* @example
* <pre>
* $redis->rPush('key1', 'A');
* $redis->rPush('key1', 'B');
* $redis->rPush('key1', 'C'); // key1 => [ 'A', 'B', 'C' ]
* $redis->lLen('key1'); // 3
* $redis->rPop('key1');
* $redis->lLen('key1'); // 2
* </pre>
*/
public function lLen($key) {}
/**
* @link https://redis.io/commands/llen
*
* @param string $key
*
* @return false|int|Redis The size of the list identified by Key exists or Redis if in multimode
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->lLen(%parametersList%)')]
public function lSize($key) {}
/**
* Return the specified element of the list stored at the specified key.
* 0 the first element, 1 the second ... -1 the last element, -2 the penultimate ...
* Return FALSE in case of a bad index or a key that doesn't point to a list.
*
* @param string $key
* @param int $index
*
* @return mixed|bool|Redis the element at this index or Redis if in multimode
*
* @throws RedisException
*
* Bool FALSE if the key identifies a non-string data type, or no value corresponds to this index in the list Key.
*
* @link https://redis.io/commands/lindex
* @example
* <pre>
* $redis->rPush('key1', 'A');
* $redis->rPush('key1', 'B');
* $redis->rPush('key1', 'C'); // key1 => [ 'A', 'B', 'C' ]
* $redis->lIndex('key1', 0); // 'A'
* $redis->lIndex('key1', -1); // 'C'
* $redis->lIndex('key1', 10); // `FALSE`
* </pre>
*/
public function lIndex($key, $index) {}
/**
* @link https://redis.io/commands/lindex
*
* @param string $key
* @param int $index
* @return mixed|bool|Redis the element at this index or Redis if in multimode
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->lIndex(%parametersList%)')]
public function lGet($key, $index) {}
/**
* Set the list at index with the new value.
*
* @param string $key The list to modify.
* @param int $index The position of the element to change.
* @param mixed $value The new value.
*
* @return bool|Redis TRUE if the new value is setted or Redis if in multimode
* FALSE if the index is out of range, or data type identified by key is not a list.
*
* @throws RedisException
*
* @link https://redis.io/commands/lset
* @example
* <pre>
* $redis->rPush('key1', 'A');
* $redis->rPush('key1', 'B');
* $redis->rPush('key1', 'C'); // key1 => [ 'A', 'B', 'C' ]
* $redis->lIndex('key1', 0); // 'A'
* $redis->lSet('key1', 0, 'X');
* $redis->lIndex('key1', 0); // 'X'
* </pre>
*/
public function lSet($key, $index, $value) {}
/**
* Returns the specified elements of the list stored at the specified key in
* the range [start, end]. start and stop are interpretated as indices: 0 the first element,
* 1 the second ... -1 the last element, -2 the penultimate ...
*
* @param string $key The list to query.
* @param int $start The beginning index to retrieve. This number can be negative meaning start from the end of the list.
* @param int $end The end index to retrieve. This can also be negative to start from the end of the list.
*
* @return array|Redis containing the values in specified range or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/lrange
* @example
* <pre>
* $redis->rPush('key1', 'A');
* $redis->rPush('key1', 'B');
* $redis->rPush('key1', 'C');
* $redis->lRange('key1', 0, -1); // array('A', 'B', 'C')
* </pre>
*/
public function lRange($key, $start, $end) {}
/**
* @link https://redis.io/commands/lrange
*
* @param string $key
* @param int $start
* @param int $end
* @return array|Redis returns Redis if in multimode
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->lRange(%parametersList%)')]
public function lGetRange($key, $start, $end) {}
/**
* Trims an existing list so that it will contain only a specified range of elements.
*
* @param string $key The list to trim
* @param int $start The starting index to keep
* @param int $end The ending index to keep.
*
* @return array|false|Redis Bool return FALSE if the key identify a non-list value or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/ltrim
* @example
* <pre>
* $redis->rPush('key1', 'A');
* $redis->rPush('key1', 'B');
* $redis->rPush('key1', 'C');
* $redis->lRange('key1', 0, -1); // array('A', 'B', 'C')
* $redis->lTrim('key1', 0, 1);
* $redis->lRange('key1', 0, -1); // array('A', 'B')
* </pre>
*/
public function lTrim($key, $start, $end) {}
/**
* @link https://redis.io/commands/ltrim
*
* @param string $key
* @param int $start
* @param int $stop
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->lTrim(%parametersList%)')]
public function listTrim($key, $start, $stop) {}
/**
* Removes the first count occurrences of the value element from the list.
* If count is zero, all the matching elements are removed. If count is negative,
* elements are removed from tail to head.
*
* @param string $key The list to truncate.
* @param mixed $value The value to remove.
* @param int $count How many elements matching the value to remove.
*
* @return int|bool|Redis the number of elements to remove or Redis if in multimode
* bool FALSE if the value identified by key is not a list.
*
* @throws RedisException
*
* @link https://redis.io/commands/lrem
* @example
* <pre>
* $redis->lPush('key1', 'A');
* $redis->lPush('key1', 'B');
* $redis->lPush('key1', 'C');
* $redis->lPush('key1', 'A');
* $redis->lPush('key1', 'A');
*
* $redis->lRange('key1', 0, -1); // array('A', 'A', 'C', 'B', 'A')
* $redis->lRem('key1', 'A', 2); // 2
* $redis->lRange('key1', 0, -1); // array('C', 'B', 'A')
* </pre>
*/
public function lRem($key, $value, $count = 0) {}
/**
* @link https://redis.io/commands/lremove
*
* @param string $key
* @param string $value
* @param int $count
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->lRem(%parametersList%)')]
public function lRemove($key, $value, $count) {}
/**
* Insert value in the list before or after the pivot value. the parameter options
* specify the position of the insert (before or after). If the list didn't exists,
* or the pivot didn't exists, the value is not inserted.
*
* @param string $key
* @param string $position Redis::BEFORE | Redis::AFTER
* @param mixed $pivot
* @param mixed $value
*
* @return false|int|Redis The number of the elements in the list, -1 if the pivot didn't exists or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/linsert
* @example
* <pre>
* $redis->del('key1');
* $redis->lInsert('key1', Redis::AFTER, 'A', 'X'); // 0
*
* $redis->lPush('key1', 'A');
* $redis->lPush('key1', 'B');
* $redis->lPush('key1', 'C');
*
* $redis->lInsert('key1', Redis::BEFORE, 'C', 'X'); // 4
* $redis->lRange('key1', 0, -1); // array('A', 'B', 'X', 'C')
*
* $redis->lInsert('key1', Redis::AFTER, 'C', 'Y'); // 5
* $redis->lRange('key1', 0, -1); // array('A', 'B', 'X', 'C', 'Y')
*
* $redis->lInsert('key1', Redis::AFTER, 'W', 'value'); // -1
* </pre>
*/
public function lInsert($key, $position, $pivot, $value) {}
/**
* Adds a values to the set value stored at key.
*
* @param string $key Required key
* @param mixed $value
* @param mixed ...$other_values Variadic list of values
*
* @return int|bool|Redis The number of elements added to the set or Redis if in multimode
* If this value is already in the set, FALSE is returned
*
* @link https://redis.io/commands/sadd
* @example
* <pre>
* $redis->sAdd('k', 'v1'); // int(1)
* $redis->sAdd('k', 'v1', 'v2', 'v3'); // int(2)
* </pre>
*/
public function sAdd(string $key, $value, ...$other_values) {}
/**
* Removes the specified members from the set value stored at key.
*
* @param string $key
* @param mixed $value
* @param mixed ...$other_values Variadic list of members
*
* @return false|int|Redis The number of elements removed from the set or Redis if in multimode
*
* @link https://redis.io/commands/srem
* @example
* <pre>
* var_dump( $redis->sAdd('k', 'v1', 'v2', 'v3') ); // int(3)
* var_dump( $redis->sRem('k', 'v2', 'v3') ); // int(2)
* var_dump( $redis->sMembers('k') );
* //// Output:
* // array(1) {
* // [0]=> string(2) "v1"
* // }
* </pre>
*/
public function sRem(string $key, $value, ...$other_values) {}
/**
* @link https://redis.io/commands/srem
*
* @param string $key
* @param string|mixed ...$member1
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->sRem(%parametersList%)')]
public function sRemove($key, ...$member1) {}
/**
* Moves the specified member from the set at srcKey to the set at dstKey.
*
* @param string $srcKey
* @param string $dstKey
* @param mixed $member
*
* @return bool|Redis If the operation is successful, return TRUE or Redis if in multimode
* If the srcKey and/or dstKey didn't exist, and/or the member didn't exist in srcKey, FALSE is returned.
*
* @throws RedisException
*
* @link https://redis.io/commands/smove
* @example
* <pre>
* $redis->sAdd('key1' , 'set11');
* $redis->sAdd('key1' , 'set12');
* $redis->sAdd('key1' , 'set13'); // 'key1' => {'set11', 'set12', 'set13'}
* $redis->sAdd('key2' , 'set21');
* $redis->sAdd('key2' , 'set22'); // 'key2' => {'set21', 'set22'}
* $redis->sMove('key1', 'key2', 'set13'); // 'key1' => {'set11', 'set12'}
* // 'key2' => {'set21', 'set22', 'set13'}
* </pre>
*/
public function sMove($srcKey, $dstKey, $member) {}
/**
* Checks if value is a member of the set stored at the key key.
*
* @param string $key
* @param mixed $value
*
* @return bool|Redis TRUE if value is a member of the set at key key, FALSE otherwise or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/sismember
* @example
* <pre>
* $redis->sAdd('key1' , 'set1');
* $redis->sAdd('key1' , 'set2');
* $redis->sAdd('key1' , 'set3'); // 'key1' => {'set1', 'set2', 'set3'}
*
* $redis->sIsMember('key1', 'set1'); // TRUE
* $redis->sIsMember('key1', 'setX'); // FALSE
* </pre>
*/
public function sIsMember(string $key, $value) {}
/**
* @link https://redis.io/commands/sismember
*
* @param string $key
* @param string|mixed $value
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->sIsMember(%parametersList%)')]
public function sContains($key, $value) {}
/**
* Returns the cardinality of the set identified by key.
*
* @param string $key
*
* @return false|int|Redis the cardinality of the set identified by key, 0 if the set doesn't exist or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/scard
* @example
* <pre>
* $redis->sAdd('key1' , 'set1');
* $redis->sAdd('key1' , 'set2');
* $redis->sAdd('key1' , 'set3'); // 'key1' => {'set1', 'set2', 'set3'}
* $redis->sCard('key1'); // 3
* $redis->sCard('keyX'); // 0
* </pre>
*/
public function sCard($key) {}
/**
* Removes and returns a random element from the set value at Key.
*
* @param string $key The set in question.
* @param int $count An optional number of members to pop. This defaults to removing one element.
*
* @return string|mixed|array|bool|Redis "popped" values or Redis if in multimode
* bool FALSE if set identified by key is empty or doesn't exist.
*
* @throws RedisException
*
* @link https://redis.io/commands/spop
* @example
* <pre>
* $redis->sAdd('key1' , 'set1');
* $redis->sAdd('key1' , 'set2');
* $redis->sAdd('key1' , 'set3'); // 'key1' => {'set3', 'set1', 'set2'}
* $redis->sPop('key1'); // 'set1', 'key1' => {'set3', 'set2'}
* $redis->sPop('key1'); // 'set3', 'key1' => {'set2'}
*
* // With count
* $redis->sAdd('key2', 'set1', 'set2', 'set3');
* var_dump( $redis->sPop('key2', 3) ); // Will return all members but in no particular order
*
* // array(3) {
* // [0]=> string(4) "set2"
* // [1]=> string(4) "set3"
* // [2]=> string(4) "set1"
* // }
* </pre>
*/
public function sPop($key, $count = 0) {}
/**
* Returns a random element(s) from the set value at Key, without removing it.
*
* @param string $key The set to query.
* @param int $count An optional count of members to return.
*
* If this value is positive, Redis will return *up to* the requested
* number but with unique elements that will never repeat. This means
* you may recieve fewer then `$count` replies.
*
* If the number is negative, Redis will return the exact number requested
* but the result may contain duplicate elements.
*
* @return string|mixed|array|bool|Redis value(s) from the set or Redis if in multimode
* bool FALSE if set identified by key is empty or doesn't exist and count argument isn't passed.
*
* @throws RedisException
*
* @link https://redis.io/commands/srandmember
* @example
* <pre>
* $redis->sAdd('key1' , 'one');
* $redis->sAdd('key1' , 'two');
* $redis->sAdd('key1' , 'three'); // 'key1' => {'one', 'two', 'three'}
*
* var_dump( $redis->sRandMember('key1') ); // 'key1' => {'one', 'two', 'three'}
*
* // string(5) "three"
*
* var_dump( $redis->sRandMember('key1', 2) ); // 'key1' => {'one', 'two', 'three'}
*
* // array(2) {
* // [0]=> string(2) "one"
* // [1]=> string(5) "three"
* // }
* </pre>
*/
public function sRandMember($key, $count = 0) {}
/**
* Returns the members of a set resulting from the intersection of all the sets
* held at the specified keys. If just a single key is specified, then this command
* produces the members of this set. If one of the keys is missing, FALSE is returned.
*
* @param string $key1 keys identifying the different sets on which we will apply the intersection.
* @param string ...$otherKeys variadic list of keys
*
* @return array|false|Redis contain the result of the intersection between those keys or Redis if in multimode
* If the intersection between the different sets is empty, the return value will be empty array.
*
* @throws RedisException
*
* @link https://redis.io/commands/sinter
* @example
* <pre>
* $redis->sAdd('key1', 'val1');
* $redis->sAdd('key1', 'val2');
* $redis->sAdd('key1', 'val3');
* $redis->sAdd('key1', 'val4');
*
* $redis->sAdd('key2', 'val3');
* $redis->sAdd('key2', 'val4');
*
* $redis->sAdd('key3', 'val3');
* $redis->sAdd('key3', 'val4');
*
* var_dump($redis->sInter('key1', 'key2', 'key3'));
*
* //array(2) {
* // [0]=>
* // string(4) "val4"
* // [1]=>
* // string(4) "val3"
* //}
* </pre>
*/
public function sInter($key1, ...$otherKeys) {}
/**
* Performs a sInter command and stores the result in a new set.
*
* @param array|string $key Either a string key, or an array of keys (with at least two elements,
* consisting of the destination key name and one or more source keys names.
* @param string ...$otherKeys If the first argument was a string, subsequent arguments should be source key names.
*
* @return int|false|Redis The cardinality of the resulting set, or FALSE in case of a missing key or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/sinterstore
* @example
* <pre>
* $redis->sAdd('key1', 'val1');
* $redis->sAdd('key1', 'val2');
* $redis->sAdd('key1', 'val3');
* $redis->sAdd('key1', 'val4');
*
* $redis->sAdd('key2', 'val3');
* $redis->sAdd('key2', 'val4');
*
* $redis->sAdd('key3', 'val3');
* $redis->sAdd('key3', 'val4');
*
* var_dump($redis->sInterStore('output', 'key1', 'key2', 'key3'));
* var_dump($redis->sMembers('output'));
*
* //int(2)
* //
* //array(2) {
* // [0]=>
* // string(4) "val4"
* // [1]=>
* // string(4) "val3"
* //}
* </pre>
*/
public function sInterStore(string $key, ...$otherKeys) {}
/**
* Performs the union between N sets and returns it.
*
* @param string $key1 first key for union
* @param string ...$otherKeys variadic list of keys corresponding to sets in redis
*
* @return array|false|Redis The union of all these sets or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/sunionstore
* @example
* <pre>
* $redis->sAdd('s0', '1');
* $redis->sAdd('s0', '2');
* $redis->sAdd('s1', '3');
* $redis->sAdd('s1', '1');
* $redis->sAdd('s2', '3');
* $redis->sAdd('s2', '4');
*
* var_dump($redis->sUnion('s0', 's1', 's2'));
*
* array(4) {
* // [0]=>
* // string(1) "3"
* // [1]=>
* // string(1) "4"
* // [2]=>
* // string(1) "1"
* // [3]=>
* // string(1) "2"
* //}
* </pre>
*/
public function sUnion($key1, ...$otherKeys) {}
/**
* Performs the same action as sUnion, but stores the result in the first key
*
* @param string $dstKey The destination key
* @param string $key1 The first source key
* @param string ...$otherKeys One or more additional source keys
*
* @return false|int|Redis Any number of keys corresponding to sets in redis or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/sunionstore
* @example
* <pre>
* $redis->del('s0', 's1', 's2');
*
* $redis->sAdd('s0', '1');
* $redis->sAdd('s0', '2');
* $redis->sAdd('s1', '3');
* $redis->sAdd('s1', '1');
* $redis->sAdd('s2', '3');
* $redis->sAdd('s2', '4');
*
* var_dump($redis->sUnionStore('dst', 's0', 's1', 's2'));
* var_dump($redis->sMembers('dst'));
*
* //int(4)
* //array(4) {
* // [0]=>
* // string(1) "3"
* // [1]=>
* // string(1) "4"
* // [2]=>
* // string(1) "1"
* // [3]=>
* // string(1) "2"
* //}
* </pre>
*/
public function sUnionStore($dstKey, $key1, ...$otherKeys) {}
/**
* Performs the difference between N sets and returns it.
*
* @param string $key1 first key for diff
* @param string ...$otherKeys variadic list of keys corresponding to sets in redis
*
* @return array|false|Redis string[] The difference of the first set will all the others or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/sdiff
* @example
* <pre>
* $redis->del('s0', 's1', 's2');
*
* $redis->sAdd('s0', '1');
* $redis->sAdd('s0', '2');
* $redis->sAdd('s0', '3');
* $redis->sAdd('s0', '4');
*
* $redis->sAdd('s1', '1');
* $redis->sAdd('s2', '3');
*
* var_dump($redis->sDiff('s0', 's1', 's2'));
*
* //array(2) {
* // [0]=>
* // string(1) "4"
* // [1]=>
* // string(1) "2"
* //}
* </pre>
*/
public function sDiff($key1, ...$otherKeys) {}
/**
* Performs the same action as sDiff, but stores the result in the first key
*
* @param string $dstKey the key to store the diff into.
* @param string $key1 first key for diff
* @param string ...$otherKeys variadic list of keys corresponding to sets in redis
*
* @return int|false|Redis The cardinality of the resulting set, or FALSE in case of a missing key or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/sdiffstore
* @example
* <pre>
* $redis->del('s0', 's1', 's2');
*
* $redis->sAdd('s0', '1');
* $redis->sAdd('s0', '2');
* $redis->sAdd('s0', '3');
* $redis->sAdd('s0', '4');
*
* $redis->sAdd('s1', '1');
* $redis->sAdd('s2', '3');
*
* var_dump($redis->sDiffStore('dst', 's0', 's1', 's2'));
* var_dump($redis->sMembers('dst'));
*
* //int(2)
* //array(2) {
* // [0]=>
* // string(1) "4"
* // [1]=>
* // string(1) "2"
* //}
* </pre>
*/
public function sDiffStore($dstKey, $key1, ...$otherKeys) {}
/**
* Returns the contents of a set.
*
* @param string $key
*
* @return array|false|Redis An array of elements, the contents of the set or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/smembers
* @example
* <pre>
* $redis->del('s');
* $redis->sAdd('s', 'a');
* $redis->sAdd('s', 'b');
* $redis->sAdd('s', 'a');
* $redis->sAdd('s', 'c');
* var_dump($redis->sMembers('s'));
*
* //array(3) {
* // [0]=>
* // string(1) "c"
* // [1]=>
* // string(1) "a"
* // [2]=>
* // string(1) "b"
* //}
* // The order is random and corresponds to redis' own internal representation of the set structure.
* </pre>
*/
public function sMembers($key) {}
/**
* Check if one or more values are members of a set.
*
* @link https://redis.io/commands/smismember
* @see smember()
*
* @param string $key The set to query.
* @param string $member The first value to test if exists in the set.
* @param string ...$other_members Any number of additional values to check.
*
* @return Redis|array|false An array of integers representing whether each passed value was a member of the set.
*
* @example
* $redis->sAdd('ds9-crew', ...["Sisko", "Kira", "Dax", "Worf", "Bashir", "O'Brien"]);
* $members = $redis->sMIsMember('ds9-crew', ...['Sisko', 'Picard', 'Data', 'Worf']);
*/
public function sMisMember(string $key, string $member, string ...$other_members): array|false {}
/**
* @link https://redis.io/commands/smembers
*
* @param string $key
* @return array|Redis An array of elements, the contents of the set or Redis if in multimode
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->sMembers(%parametersList%)')]
public function sGetMembers($key) {}
/**
* Scan a set for members
*
* @param string $key The Redis SET key in question.
* @param int|null &$iterator A reference to an iterator which should be initialized to NULL that
* PhpRedis will update with the value returned from Redis after each
* subsequent call to SSCAN. Once this cursor is zero you know all
* members have been traversed.
* @param string $pattern An optional glob style pattern to match against, so Redis only
* returns the subset of members matching this pattern.
* @param int $count A hint to Redis as to how many members it should scan in one command
* before returning members for that iteration.
*
* @return array|false|Redis PHPRedis will return an array of keys or FALSE when we're done iterating or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/sscan
* @example
* <pre>
* $redis->del('myset');
* for ($i = 0; $i < 10000; $i++) {
* $redis->sAdd('myset', "member:$i");
* }
* $redis->sadd('myset', 'foofoo');
*
* $redis->setOption(Redis::OPT_SCAN, Redis::SCAN_NORETRY);
*
* $scanned = 0;
* $it = null;
*
* // Without Redis::SCAN_RETRY we may receive empty results and
* // a nonzero iterator.
* do {
* // Scan members containing '5'
* $members = $redis->sscan('myset', $it, '*5*');
* foreach ($members as $member) {
* echo "NORETRY: $member\n";
* $scanned++;
* }
* } while ($it != 0);
* echo "TOTAL: $scanned\n";
*
* $redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
*
* $scanned = 0;
* $it = null;
*
* // With Redis::SCAN_RETRY PhpRedis will never return an empty array
* // when the cursor is non-zero
* while (($members = $redis->sScan('set', $it, '*5*'))) {
* foreach ($members as $member) {
* echo "RETRY: $member\n";
* $scanned++;
* }
* }
* </pre>
*/
public function sScan($key, &$iterator, $pattern = null, $count = 0) {}
/**
* Sets a value and returns the previous entry at that key.
*
* @param string $key
* @param mixed $value
*
* @return string|mixed|false|Redis A string (mixed, if used serializer), the previous value located at this key or false if it didn't exist or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/getset
* @example
* <pre>
* $redis->set('x', '42');
* $exValue = $redis->getSet('x', 'lol'); // return '42', replaces x by 'lol'
* $newValue = $redis->get('x')' // return 'lol'
* </pre>
*/
public function getSet($key, $value) {}
/**
* Returns a random key
*
* @return string|false|Redis an existing key in redis or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/randomkey
* @example
* <pre>
* $key = $redis->randomKey();
* $surprise = $redis->get($key); // who knows what's in there.
* </pre>
*/
public function randomKey() {}
/**
* Switches to a given database
*
* @param int $dbIndex
*
* @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/select
* @example
* <pre>
* $redis->select(0); // switch to DB 0
* $redis->set('x', '42'); // write 42 to x
* $redis->move('x', 1); // move to DB 1
* $redis->select(1); // switch to DB 1
* $redis->get('x'); // will return 42
* </pre>
*/
public function select($dbIndex) {}
/**
* Moves a key to a different database.
*
* @param string $key
* @param int $dbIndex
*
* @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/move
* @example
* <pre>
* $redis->select(0); // switch to DB 0
* $redis->set('x', '42'); // write 42 to x
* $redis->move('x', 1); // move to DB 1
* $redis->select(1); // switch to DB 1
* $redis->get('x'); // will return 42
* </pre>
*/
public function move($key, $dbIndex) {}
/**
* Renames a key
*
* @param string $srcKey
* @param string $dstKey
*
* @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/rename
* @example
* <pre>
* $redis->set('x', '42');
* $redis->rename('x', 'y');
* $redis->get('y'); // → 42
* $redis->get('x'); // → `FALSE`
* </pre>
*/
public function rename($srcKey, $dstKey) {}
/**
* @link https://redis.io/commands/rename
*
* @param string $srcKey
* @param string $dstKey
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->rename(%parametersList%)')]
public function renameKey($srcKey, $dstKey) {}
/**
* Renames a key
*
* Same as rename, but will not replace a key if the destination already exists.
* This is the same behaviour as setnx.
*
* @param string $srcKey
* @param string $dstKey
*
* @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/renamenx
* @example
* <pre>
* $redis->set('x', '42');
* $redis->rename('x', 'y');
* $redis->get('y'); // → 42
* $redis->get('x'); // → `FALSE`
* </pre>
*/
public function renameNx($srcKey, $dstKey) {}
/**
* Sets an expiration in seconds on the key in question. If connected to
* redis-server >= 7.0.0 you may send an additional "mode" argument which
* modifies how the command will execute.
*
* @param string $key The key to set an expiration on.
* @param int $ttl The key's remaining Time To Live, in seconds
* @param string|null $mode A two character modifier that changes how the command works.
* NX - Set expiry only if key has no expiry
* XX - Set expiry only if key has an expiry
* LT - Set expiry only when new expiry is < current expiry
* GT - Set expiry only when new expiry is > current expiry
*
* @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/expire
* @example
* <pre>
* $redis->set('x', '42');
* $redis->expire('x', 3); // x will disappear in 3 seconds.
* sleep(5); // wait 5 seconds
* $redis->get('x'); // will return `FALSE`, as 'x' has expired.
* </pre>
*/
public function expire($key, $ttl, $mode = null) {}
/**
* Sets an expiration date (a timeout in milliseconds) on an item
*
* If connected to Redis >= 7.0.0 you can pass an optional mode argument that modifies how the command will execute.
*
* @param string $key The key to set an expiration on.
* @param int $ttl The key's remaining Time To Live, in milliseconds
* @param string|null $mode A two character modifier that changes how the command works.
*
* @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/pexpire
* @example
* <pre>
* $redis->set('x', '42');
* $redis->pExpire('x', 11500); // x will disappear in 11500 milliseconds.
* $redis->ttl('x'); // 12
* $redis->pttl('x'); // 11500
* </pre>
*/
public function pExpire($key, $ttl, $mode = null) {}
/**
* @link https://redis.io/commands/expire
*
* @param string $key
* @param int $ttl
* @return bool|Redis returns Redis if in multimode
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->expire(%parametersList%)')]
public function setTimeout($key, $ttl) {}
/**
* Sets an expiration date (a timestamp) on an item.
*
* If connected to Redis >= 7.0.0 you can pass an optional 'mode' argument.
* @see expire() For a description of the mode argument.
*
* @param string $key The key to set an expiration on.
* @param int $timestamp The unix timestamp to expire at.
* @param string|null $mode An option 'mode' that modifies how the command acts
*
* @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/expireat
* @example
* <pre>
* $redis->set('x', '42');
* $now = time(NULL); // current timestamp
* $redis->expireAt('x', $now + 3); // x will disappear in 3 seconds.
* sleep(5); // wait 5 seconds
* $redis->get('x'); // will return `FALSE`, as 'x' has expired.
* </pre>
*/
public function expireAt($key, $timestamp, $mode = null) {}
/**
* Sets an expiration date (a timestamp) on an item. Requires a timestamp in milliseconds
*
* If connected to Redis >= 7.0.0 you can pass an optional 'mode' argument.
*
* @param string $key The key to set an expiration on.
* @param int $timestamp Unix timestamp. The key's date of death, in seconds from Epoch time
* @param string|null $mode A two character modifier that changes how the command works.
*
* @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/pexpireat
* @example
* <pre>
* $redis->set('x', '42');
* $redis->pExpireAt('x', 1555555555005);
* echo $redis->ttl('x'); // 218270121
* echo $redis->pttl('x'); // 218270120575
* </pre>
*/
public function pExpireAt($key, $timestamp, $mode = null) {}
/**
* Returns the keys that match a certain pattern.
*
* @param string $pattern pattern, using '*' as a wildcard
*
* @return array|false|Redis The keys that match a certain pattern or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/keys
* @example
* <pre>
* $allKeys = $redis->keys('*'); // all keys will match this.
* $keyWithUserPrefix = $redis->keys('user*');
* </pre>
*/
public function keys($pattern) {}
/**
* @param string $pattern
*
* @throws RedisException
* @link https://redis.io/commands/keys
*/
#[Deprecated(replacement: '%class%->keys(%parametersList%)')]
public function getKeys($pattern) {}
/**
* Returns the current database's size
*
* @return false|int|Redis DB size, in number of keys or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/dbsize
* @example
* <pre>
* $count = $redis->dbSize();
* echo "Redis has $count keys\n";
* </pre>
*/
public function dbSize() {}
/**
* Authenticate a Redis connection after its been established.
* Warning: The password is sent in plain-text over the network.
*
* @param mixed $credentials A string password, or an array with one or two string elements.
*
* @return bool|Redis TRUE if the connection is authenticated, FALSE otherwise or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/auth
*
* @example
* $redis->auth('password');
* $redis->auth(['password']);
* $redis->auth(['username', 'password']);
*/
public function auth($credentials) {}
/**
* Starts the background rewrite of AOF (Append-Only File)
*
* @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/bgrewriteaof
* @example $redis->bgrewriteaof();
*/
public function bgrewriteaof() {}
/**
* Changes the slave status
* Either host and port, or no parameter to stop being a slave.
*
* This method and the corresponding command in Redis has been marked deprecated
* and users should instead use replicaof() if connecting to redis-server >= 5.0.0.
*
* @param string $host [optional]
* @param int $port [optional]
*
* @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/slaveof
* @example
* <pre>
* $redis->slaveof('10.0.1.7', 6379);
* // ...
* $redis->slaveof();
* </pre>
*/
#[Deprecated(replacement: '%class%->replicaof(%parametersList%)')]
public function slaveof($host = '127.0.0.1', $port = 6379) {}
/**
* Access the Redis slowLog
*
* @param string $operation The operation you wish to perform. This can be one of the following values:
* 'GET' - Retrieve the Redis slowlog as an array.
* 'LEN' - Retrieve the length of the slowlog.
* 'RESET' - Remove all slowlog entries.
* @param int $length This optional argument can be passed when operation
* is 'get' and will specify how many elements to retrieve.
* If omitted Redis will send up to a default number of
* entries, which is configurable.
*
* Note: With Redis >= 7.0.0 you can send -1 to mean "all".
*
* @return mixed|Redis The return value of SLOWLOG will depend on which operation was performed or Redis if in multimode
* - SLOWLOG GET: Array of slowLog entries, as provided by Redis
* - SLOGLOG LEN: Integer, the length of the slowLog
* - SLOWLOG RESET: Boolean, depending on success
*
* @throws RedisException
*
* @example
* <pre>
* // Get ten slowLog entries
* $redis->slowLog('get', 10);
* // Get the default number of slowLog entries
*
* $redis->slowLog('get');
* // Reset our slowLog
* $redis->slowLog('reset');
*
* // Retrieve slowLog length
* $redis->slowLog('len');
* </pre>
*
* @link https://redis.io/commands/slowlog
*/
public function slowLog(string $operation, int $length = 0) {}
/**
* Describes the object pointed to by a key.
* The information to retrieve (string) and the key (string).
* Info can be one of the following:
* - "encoding"
* - "refcount"
* - "idletime"
*
* @param string $subcommand
* @param string $key
*
* @return string|int|false|Redis for "encoding", int for "refcount" and "idletime", FALSE if the key doesn't exist or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/object
* @example
* <pre>
* $redis->lPush('l', 'Hello, world!');
* $redis->object("encoding", "l"); // → ziplist
* $redis->object("refcount", "l"); // → 1
* $redis->object("idletime", "l"); // → 400 (in seconds, with a precision of 10 seconds).
* </pre>
*/
public function object($subcommand, $key) {}
/**
* Performs a synchronous save.
*
* @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multimode
* If a save is already running, this command will fail and return FALSE.
*
* @throws RedisException
*
* @link https://redis.io/commands/save
* @example $redis->save();
*/
public function save() {}
/**
* Performs a background save.
*
* @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multimode
* If a save is already running, this command will fail and return FALSE
*
* @throws RedisException
*
* @link https://redis.io/commands/bgsave
* @example $redis->bgSave();
*/
public function bgSave() {}
/**
* Returns the timestamp of the last disk save.
*
* @return false|int|Redis timestamp or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/lastsave
* @example $redis->lastSave();
*/
public function lastSave() {}
/**
* Blocks the current client until all the previous write commands are successfully transferred and
* acknowledged by at least the specified number of slaves.
*
* @param int $numreplicas The number of replicas we want to confirm write operaions
* @param int $timeout How long to wait (zero meaning forever).
*
* @return int|false|Redis The command returns the number of slaves reached by all the writes performed in the or Redis if in multimode
* context of the current connection
*
* @throws RedisException
*
* @link https://redis.io/commands/wait
* @example $redis->wait(2, 1000);
*/
public function wait($numreplicas, $timeout) {}
/**
* Returns the type of data pointed by a given key.
*
* @param string $key
*
* @return false|int|Redis returns Redis if in multimode
* Depending on the type of the data pointed by the key,
* this method will return the following value:
* - string: Redis::REDIS_STRING
* - set: Redis::REDIS_SET
* - list: Redis::REDIS_LIST
* - zset: Redis::REDIS_ZSET
* - hash: Redis::REDIS_HASH
* - stream: Redis::REDIS_STREAM
* - other: Redis::REDIS_NOT_FOUND
*
* @throws RedisException
*
* @link https://redis.io/commands/type
* @example $redis->type('key');
*/
public function type(string $key) {}
/**
* Append specified string to the string stored in specified key.
*
* @param string $key
* @param mixed $value
*
* @return false|int|Redis Size of the value after the append or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/append
* @example
* <pre>
* $redis->set('key', 'value1');
* $redis->append('key', 'value2'); // 12
* $redis->get('key'); // 'value1value2'
* </pre>
*/
public function append($key, $value) {}
/**
* Return a substring of a larger string
*
* @param string $key
* @param int $start
* @param int $end
*
* @return string|Redis the substring or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/getrange
* @example
* <pre>
* $redis->set('key', 'string value');
* $redis->getRange('key', 0, 5); // 'string'
* $redis->getRange('key', -5, -1); // 'value'
* </pre>
*/
public function getRange($key, $start, $end) {}
/**
* Return a substring of a larger string
*
* @param string $key
* @param int $start
* @param int $end
*
* @throws RedisException
*/
#[Deprecated]
public function substr($key, $start, $end) {}
/**
* Changes a substring of a larger string.
*
* @param string $key
* @param int $offset
* @param string $value
*
* @return false|int|Redis the length of the string after it was modified or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/setrange
* @example
* <pre>
* $redis->set('key', 'Hello world');
* $redis->setRange('key', 6, "redis"); // returns 11
* $redis->get('key'); // "Hello redis"
* </pre>
*/
public function setRange($key, $offset, $value) {}
/**
* Get the length of a string value.
*
* @param string $key
* @return false|int|Redis The length of the string key if it exists, zero if it does not, and false on failure.
*
* @throws RedisException
*
* @link https://redis.io/commands/strlen
* @example
* <pre>
* $redis->set('key', 'value');
* $redis->strlen('key'); // 5
* </pre>
*/
public function strlen($key) {}
/**
* Return the position of the first bit set to 1 or 0 in a string. The position is returned, thinking of the
* string as an array of bits from left to right, where the first byte's most significant bit is at position 0,
* the second byte's most significant bit is at position 8, and so forth.
*
* @param string $key The key to check (must be a string)
* @param bool $bit Whether to look for an unset (0) or set (1) bit.
* @param int $start Where in the string to start looking.
* @param int $end Where in the string to stop looking.
* @param bool $bybit If true, Redis will treat $start and $end as BIT values and not bytes, so if start was 0 and end was 2, Redis would only search the first two bits.
*
* @return false|int|Redis The command returns the position of the first bit set to 1 or 0 according to the request or Redis if in multimode
* If we look for set bits (the bit argument is 1) and the string is empty or composed of just
* zero bytes, -1 is returned. If we look for clear bits (the bit argument is 0) and the string
* only contains bit set to 1, the function returns the first bit not part of the string on the
* right. So if the string is three bytes set to the value 0xff the command BITPOS key 0 will
* return 24, since up to bit 23 all the bits are 1. Basically, the function considers the right
* of the string as padded with zeros if you look for clear bits and specify no range or the
* start argument only. However, this behavior changes if you are looking for clear bits and
* specify a range with both start and end. If no clear bit is found in the specified range, the
* function returns -1 as the user specified a clear range and there are no 0 bits in that range.
*
* @throws RedisException
*
* @link https://redis.io/commands/bitpos
* @example
* <pre>
* $redis->set('key', '\xff\xff');
* $redis->bitpos('key', 1); // int(0)
* $redis->bitpos('key', 1, 1); // int(8)
* $redis->bitpos('key', 1, 3); // int(-1)
* $redis->bitpos('key', 0); // int(16)
* $redis->bitpos('key', 0, 1); // int(16)
* $redis->bitpos('key', 0, 1, 5); // int(-1)
* </pre>
*/
public function bitpos($key, $bit, $start = 0, $end = -1, $bybit = false) {}
/**
* Return a single bit out of a larger string
*
* @param string $key
* @param int $offset
*
* @return false|int|Redis the bit value (0 or 1) or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/getbit
* @example
* <pre>
* $redis->set('key', "\x7f"); // this is 0111 1111
* $redis->getBit('key', 0); // 0
* $redis->getBit('key', 1); // 1
* </pre>
*/
public function getBit($key, $offset) {}
/**
* Changes a single bit of a string.
*
* @param string $key
* @param int $offset
* @param bool|int $value bool or int (1 or 0)
*
* @return false|int|Redis 0 or 1, the value of the bit before it was set or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/setbit
* @example
* <pre>
* $redis->set('key', "*"); // ord("*") = 42 = 0x2f = "0010 1010"
* $redis->setBit('key', 5, 1); // returns 0
* $redis->setBit('key', 7, 1); // returns 0
* $redis->get('key'); // chr(0x2f) = "/" = b("0010 1111")
* </pre>
*/
public function setBit($key, $offset, $value) {}
/**
* Count bits in a string
*
* @param string $key The key in question (must be a string key)
* @param int $start The index where Redis should start counting. If omitted it defaults to zero, which means the start of the string.
* @param int $end The index where Redis should stop counting. If omitted it defaults to -1, meaning the very end of the string.
* @param bool $bybit Whether or not Redis should treat $start and $end as bit positions, rather than bytes.
*
* @return false|int|Redis The number of bits set to 1 in the value behind the input key or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/bitcount
* @example
* <pre>
* $redis->set('bit', '345'); // // 11 0011 0011 0100 0011 0101
* var_dump( $redis->bitCount('bit', 0, 0) ); // int(4)
* var_dump( $redis->bitCount('bit', 1, 1) ); // int(3)
* var_dump( $redis->bitCount('bit', 2, 2) ); // int(4)
* var_dump( $redis->bitCount('bit', 0, 2) ); // int(11)
* </pre>
*/
public function bitCount($key, $start = 0, $end = -1, $bybit = false) {}
/**
* Bitwise operation on multiple keys.
*
* @param string $operation either "AND", "OR", "NOT", "XOR"
* @param string $retKey return key
* @param string $key1 first key
* @param string ...$otherKeys variadic list of keys
*
* @return false|int|Redis The size of the string stored in the destination key or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/bitop
* @example
* <pre>
* $redis->set('bit1', '1'); // 11 0001
* $redis->set('bit2', '2'); // 11 0010
*
* $redis->bitOp('AND', 'bit', 'bit1', 'bit2'); // bit = 110000
* $redis->bitOp('OR', 'bit', 'bit1', 'bit2'); // bit = 110011
* $redis->bitOp('NOT', 'bit', 'bit1', 'bit2'); // bit = 110011
* $redis->bitOp('XOR', 'bit', 'bit1', 'bit2'); // bit = 11
* </pre>
*/
public function bitOp($operation, $retKey, $key1, ...$otherKeys) {}
/**
* Removes all entries from the current database.
*
* @param bool|null $async Whether to perform the task in a blocking or non-blocking way. Requires server version 4.0.0 or greater
*
* @return bool|Redis Always TRUE or Redis if in multimode
* @throws RedisException
* @link https://redis.io/commands/flushdb
* @example $redis->flushDB();
*/
public function flushDB($async = null) {}
/**
* Removes all entries from all databases.
*
* @param bool|null $async Whether to perform the task in a blocking or non-blocking way. Requires server version 4.0.0 or greater
*
* @return bool|Redis Always TRUE or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/flushall
* @example $redis->flushAll();
*/
public function flushAll($async = null) {}
/**
* Sort the contents of a Redis key in various ways.
*
* @param string $key The key you wish to sort
* @param array|null $options Various options controlling how you would like the data sorted.
* See blow for a detailed description of this options array.
* 'SORT' => 'ASC'|| 'DESC' // Sort in descending or descending order.
* 'ALPHA' => true || false // Whether to sort alphanumerically.
* 'LIMIT' => [0, 10] // Return a subset of the data at offset, count
* 'BY' => 'weight_*' // For each element in the key, read data from the
* external key weight_* and sort based on that value.
* 'GET' => 'weight_*' // For each element in the source key, retrieve the
* data from key weight_* and return that in the result
* rather than the source keys' element. This can
* be used in combination with 'BY'
*
* @return mixed This command can either return an array with the sorted data or the
* number of elements placed in a destination set when using the STORE option.
*
* @throws RedisException
*
* @link https://redis.io/commands/sort
* @example
* <pre>
* $redis->del('s');
* $redis->sadd('s', 5);
* $redis->sadd('s', 4);
* $redis->sadd('s', 2);
* $redis->sadd('s', 1);
* $redis->sadd('s', 3);
*
* var_dump($redis->sort('s')); // 1,2,3,4,5
* var_dump($redis->sort('s', array('sort' => 'desc'))); // 5,4,3,2,1
* var_dump($redis->sort('s', array('sort' => 'desc', 'store' => 'out'))); // (int)5
* </pre>
*/
public function sort($key, $options = null) {}
/**
* Returns an associative array of strings and integers
*
* If connected to Redis server >= 7.0.0 you may pass multiple optional sections.
*
* @param string ...$sections Optional section(s) you wish Redis server to return.
* SERVER | CLIENTS | MEMORY | PERSISTENCE | STATS | REPLICATION | CPU | CLUSTER | KEYSPACE | COMMANDSTATS
*
* Returns an associative array of strings and integers, with the following keys:
* - redis_version
* - redis_git_sha1
* - redis_git_dirty
* - arch_bits
* - multiplexing_api
* - process_id
* - uptime_in_seconds
* - uptime_in_days
* - lru_clock
* - used_cpu_sys
* - used_cpu_user
* - used_cpu_sys_children
* - used_cpu_user_children
* - connected_clients
* - connected_slaves
* - client_longest_output_list
* - client_biggest_input_buf
* - blocked_clients
* - used_memory
* - used_memory_human
* - used_memory_peak
* - used_memory_peak_human
* - mem_fragmentation_ratio
* - mem_allocator
* - loading
* - aof_enabled
* - changes_since_last_save
* - bgsave_in_progress
* - last_save_time
* - total_connections_received
* - total_commands_processed
* - expired_keys
* - evicted_keys
* - keyspace_hits
* - keyspace_misses
* - hash_max_zipmap_entries
* - hash_max_zipmap_value
* - pubsub_channels
* - pubsub_patterns
* - latest_fork_usec
* - vm_enabled
* - role
*
* @return array|false|Redis returns Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/info
* @example
* <pre>
* $redis->info();
*
* or
*
* $redis->info("COMMANDSTATS"); //Information on the commands that have been run (>=2.6 only)
* $redis->info("CPU"); // just CPU information from Redis INFO
* </pre>
*/
public function info(...$sections) {}
/**
* Returns an indexed array whose first element is the role
*
* @return mixed|Redis Will return an array with the role of the connected instance unless there is an error. returns Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/role
* @example
* <pre>
* $redis->role();
* </pre>
*/
public function role() {}
/**
* Resets the statistics reported by Redis using the INFO command (`info()` function).
* These are the counters that are reset:
* - Keyspace hits
* - Keyspace misses
* - Number of commands processed
* - Number of connections received
* - Number of expired keys
*
* @return bool|Redis `TRUE` in case of success, `FALSE` in case of failure or Redis if in multimode
*
* @throws RedisException
*
* @example $redis->resetStat();
* @link https://redis.io/commands/config-resetstat
*/
#[Deprecated(replacement: "%class%->rawCommand('CONFIG', 'RESETSTAT')")]
public function resetStat() {}
/**
* Returns the time to live left for a given key, in seconds. If the key doesn't exist, FALSE is returned.
*
* @param string $key
*
* @return int|bool|Redis the time left to live in seconds or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/ttl
* @example
* <pre>
* $redis->setex('key', 123, 'test');
* $redis->ttl('key'); // int(123)
* </pre>
*/
public function ttl($key) {}
/**
* Returns a time to live left for a given key, in milliseconds.
*
* If the key doesn't exist, FALSE is returned.
*
* @param string $key
*
* @return int|bool|Redis the time left to live in milliseconds or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/pttl
* @example
* <pre>
* $redis->setex('key', 123, 'test');
* $redis->pttl('key'); // int(122999)
* </pre>
*/
public function pttl($key) {}
/**
* Remove the expiration timer from a key.
*
* @param string $key
*
* @return bool|Redis TRUE if a timeout was removed, FALSE if the key didn’t exist or didn’t have an expiration timer or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/persist
* @example $redis->persist('key');
*/
public function persist($key) {}
/**
* Sets multiple key-value pairs in one atomic command.
* MSETNX only returns TRUE if all the keys were set (see SETNX).
*
* @param array<string, string> $array Pairs: array(key => value, ...)
*
* @return bool|Redis TRUE in case of success, FALSE in case of failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/mset
* @example
* <pre>
* $redis->mSet(array('key0' => 'value0', 'key1' => 'value1'));
* var_dump($redis->get('key0'));
* var_dump($redis->get('key1'));
* // Output:
* // string(6) "value0"
* // string(6) "value1"
* </pre>
*/
public function mSet($array) {}
/**
* Get the values of all the specified keys.
* If one or more keys dont exist, the array will contain FALSE at the position of the key.
*
* @param array $keys Array containing the list of the keys
*
* @return array|Redis Array containing the values related to keys in argument or Redis if in multimode
*
* @throws RedisException
*
* @example
* <pre>
* $redis->set('key1', 'value1');
* $redis->set('key2', 'value2');
* $redis->set('key3', 'value3');
* $redis->getMultiple(array('key1', 'key2', 'key3')); // array('value1', 'value2', 'value3');
* $redis->getMultiple(array('key0', 'key1', 'key5')); // array(`FALSE`, 'value2', `FALSE`);
* </pre>
*/
#[Deprecated(replacement: '%class%->mGet(%parametersList%)')]
public function getMultiple(array $keys) {}
/**
* Returns the values of all specified keys.
*
* For every key that does not hold a string value or does not exist,
* the special value false is returned. Because of this, the operation never fails.
*
* @param array $array
*
* @return false|list<false|string>|Redis returns Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/mget
* @example
* <pre>
* $redis->del('x', 'y', 'z', 'h'); // remove x y z
* $redis->mset(array('x' => 'a', 'y' => 'b', 'z' => 'c'));
* $redis->hset('h', 'field', 'value');
* var_dump($redis->mget(array('x', 'y', 'z', 'h')));
* // Output:
* // array(3) {
* // [0]=> string(1) "a"
* // [1]=> string(1) "b"
* // [2]=> string(1) "c"
* // [3]=> bool(false)
* // }
* </pre>
*/
public function mGet(array $array) {}
/**
* Set one ore more string keys but only if none of the key exist.
*
* @see mSet()
*
* @param array<string, string> $array
* @return false|int|Redis 1 (if the keys were set) or 0 (no key was set) or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/msetnx
* @example $redis->msetnx(['foo' => 'bar', 'baz' => 'bop']);
*/
public function msetnx(array $array) {}
/**
* Pops a value from the tail of a list, and pushes it to the front of another list.
* Also return this value.
*
* @since redis >= 1.1
*
* @param string $srcKey
* @param string $dstKey
*
* @return string|mixed|false|Redis The element that was moved in case of success, FALSE in case of failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/rpoplpush
* @example
* <pre>
* $redis->del('x', 'y');
*
* $redis->lPush('x', 'abc');
* $redis->lPush('x', 'def');
* $redis->lPush('y', '123');
* $redis->lPush('y', '456');
*
* // move the last of x to the front of y.
* var_dump($redis->rpoplpush('x', 'y'));
* var_dump($redis->lRange('x', 0, -1));
* var_dump($redis->lRange('y', 0, -1));
*
* //Output:
* //
* //string(3) "abc"
* //array(1) {
* // [0]=>
* // string(3) "def"
* //}
* //array(3) {
* // [0]=>
* // string(3) "abc"
* // [1]=>
* // string(3) "456"
* // [2]=>
* // string(3) "123"
* //}
* </pre>
*/
public function rPopLPush($srcKey, $dstKey) {}
/**
* A blocking version of rPopLPush, with an integral timeout in the third parameter.
*
* @param string $srcKey
* @param string $dstKey
* @param int|float $timeout The number of seconds to wait. Note that you must be connected to Redis >= 6.0.0 to send a floating point timeout.
*
* @return string|mixed|bool|Redis The element that was moved in case of success, FALSE in case of timeout or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/brpoplpush
*/
public function bRPopLPush($srcKey, $dstKey, $timeout) {}
/**
* Adds the specified member with a given score to the sorted set stored at key
*
* @param string $key The sorted set in question.
* @param array|float $score_or_options Either the score for the first element, or an array of options.
* 'NX', # Only update elements that already exist
* 'NX', # Only add new elements but don't update existing ones.
* 'LT' # Only update existing elements if the new score is
* # less than the existing one.
* 'GT' # Only update existing elements if the new score is
* # greater than the existing one.
* 'CH' # Instead of returning the number of elements added,
* # Redis will return the number Of elements that were
* # changed in the operation.
* 'INCR' # Instead of setting each element to the provide score,
* # increment the element by the
* # provided score, much like ZINCRBY. When this option
* # is passed, you may only send a single score and member.
*
* Note: 'GX', 'LT', and 'NX' cannot be passed together, and PhpRedis
* will send whichever one is last in the options array.
*
* @param mixed $more_scores_and_mems A variadic number of additional scores and members.
*
* @return false|int|Redis Number of values added or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/zadd
* @example
* <pre>
* $redis->zAdd('z', 1, 'v1', 2, 'v2', 3, 'v3', 4, 'v4' ); // int(2)
* $redis->zRem('z', 'v2', 'v3'); // int(2)
* $redis->zAdd('z', ['NX'], 5, 'v5'); // int(1)
* $redis->zAdd('z', ['NX'], 6, 'v5'); // int(0)
* $redis->zAdd('z', 7, 'v6'); // int(1)
* $redis->zAdd('z', 8, 'v6'); // int(0)
*
* var_dump( $redis->zRange('z', 0, -1) );
* // Output:
* // array(4) {
* // [0]=> string(2) "v1"
* // [1]=> string(2) "v4"
* // [2]=> string(2) "v5"
* // [3]=> string(2) "v8"
* // }
*
* var_dump( $redis->zRange('z', 0, -1, true) );
* // Output:
* // array(4) {
* // ["v1"]=> float(1)
* // ["v4"]=> float(4)
* // ["v5"]=> float(5)
* // ["v6"]=> float(8)
* </pre>
*/
public function zAdd($key, $score_or_options, ...$more_scores_and_mems) {}
/**
* Returns a range of elements from the ordered set stored at the specified key,
* with values in the range [start, end]. start and stop are interpreted as zero-based indices:
* 0 the first element,
* 1 the second ...
* -1 the last element,
* -2 the penultimate ...
*
* @param string $key The sorted set in question.
* @param string|int $start The starting index we want to return.
* @param string|int $end The final index we want to return.
*
* @param array|bool|null $options This value may either be an array of options to pass to
* the command, or for historical purposes a boolean which
* controls just the 'WITHSCORES' option.
* 'WITHSCORES' => true, # Return both scores and members.
* 'LIMIT' => [10, 10], # Start at offset 10 and return 10 elements.
* 'REV' # Return the elements in reverse order
* 'BYSCORE', # Treat `start` and `end` as scores instead
* 'BYLEX' # Treat `start` and `end` as lexicographical values.
* Note: 'BYLEX' and 'BYSCORE' are mutually exclusive.
*
* @return array|Redis Array containing the values in specified range or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/zrange
* @example
* <pre>
* $redis->zAdd('key1', 0, 'val0');
* $redis->zAdd('key1', 2, 'val2');
* $redis->zAdd('key1', 10, 'val10');
* $redis->zRange('key1', 0, -1); // array('val0', 'val2', 'val10')
* // with scores
* $redis->zRange('key1', 0, -1, true); // array('val0' => 0, 'val2' => 2, 'val10' => 10)
* </pre>
*/
public function zRange($key, $start, $end, $options = null) {}
/**
* Deletes a specified member from the ordered set.
*
* @param string $key
* @param string|mixed $member1
* @param string|mixed ...$otherMembers
*
* @return false|int|Redis Number of deleted values or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/zrem
* @example
* <pre>
* $redis->zAdd('z', 1, 'v1', 2, 'v2', 3, 'v3', 4, 'v4' ); // int(2)
* $redis->zRem('z', 'v2', 'v3'); // int(2)
* var_dump( $redis->zRange('z', 0, -1) );
* //// Output:
* // array(2) {
* // [0]=> string(2) "v1"
* // [1]=> string(2) "v4"
* // }
* </pre>
*/
public function zRem($key, $member1, ...$otherMembers) {}
/**
* @link https://redis.io/commands/zrem
*
* @param string $key
* @param string|mixed $member1
* @param string|mixed ...$otherMembers
*
* @return false|int|Redis Number of deleted values or Redis if in multimode
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->zRem(%parametersList%)')]
public function zDelete($key, $member1, ...$otherMembers) {}
/**
* Returns the elements of the sorted set stored at the specified key in the range [start, end]
* in reverse order. start and stop are interpretated as zero-based indices:
* 0 the first element,
* 1 the second ...
* -1 the last element,
* -2 the penultimate ...
*
* @param string $key The sorted set in question.
* @param int $start The index to start listing elements
* @param int $end The index to stop listing elements.
* @param mixed $scores Whether or not Redis should also return each members score.
*
* @return array|Redis Array containing the values in specified range or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/zrevrange
* @example
* <pre>
* $redis->zAdd('key', 0, 'val0');
* $redis->zAdd('key', 2, 'val2');
* $redis->zAdd('key', 10, 'val10');
* $redis->zRevRange('key', 0, -1); // array('val10', 'val2', 'val0')
*
* // with scores
* $redis->zRevRange('key', 0, -1, true); // array('val10' => 10, 'val2' => 2, 'val0' => 0)
* $redis->zRevRange('key', 0, -1, ['withscores' => true]);
* </pre>
*/
public function zRevRange($key, $start, $end, $scores = null) {}
/**
* Returns the elements of the sorted set stored at the specified key which have scores in the
* range [start,end]. Adding a parenthesis before start or end excludes it from the range.
* +inf and -inf are also valid limits.
*
* zRevRangeByScore returns the same items in reverse order, when the start and end parameters are swapped.
*
* @param string $key The sorted set to query.
* @param string $start The minimum score of elements that Redis should return.
* @param string $end The maximum score of elements that Redis should return.
* @param array $options Options that change how Redis will execute the command.
*
* OPTION TYPE MEANING
* 'WITHSCORES' bool Whether to also return scores.
* 'LIMIT' [offset, count] Limit the reply to a subset of elements.
*
* @return array|false|Redis Array containing the values in specified range or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/zrangebyscore
* @example
* <pre>
* $redis->zAdd('key', 0, 'val0');
* $redis->zAdd('key', 2, 'val2');
* $redis->zAdd('key', 10, 'val10');
* $redis->zRangeByScore('key', 0, 3); // array('val0', 'val2')
* $redis->zRangeByScore('key', 0, 3, array('withscores' => TRUE); // array('val0' => 0, 'val2' => 2)
* $redis->zRangeByScore('key', 0, 3, array('limit' => array(1, 1)); // array('val2')
* $redis->zRangeByScore('key', 0, 3, array('withscores' => TRUE, 'limit' => array(1, 1)); // array('val2' => 2)
* </pre>
*/
public function zRangeByScore($key, $start, $end, array $options = []) {}
/**
* List elements from a Redis sorted set by score, highest to lowest
*
* @param string $key The sorted set to query.
* @param string $start The highest score to include in the results.
* @param string $end The lowest score to include in the results.
* @param array $options An options array that modifies how the command executes.
* <code>
* $options = [
* 'WITHSCORES' => true|false # Whether or not to return scores
* 'LIMIT' => [offset, count] # Return a subset of the matching members
* ];
* </code>
*
* NOTE: For legacy reason, you may also simply pass `true` for the
* options argument, to mean `WITHSCORES`.
*
* @return array|false|Redis returns Redis if in multimode
*
* @throws RedisException
* @see zRangeByScore()
*
* @example
* $redis->zadd('oldest-people', 122.4493, 'Jeanne Calment', 119.2932, 'Kane Tanaka',
* 119.2658, 'Sarah Knauss', 118.7205, 'Lucile Randon',
* 117.7123, 'Nabi Tajima', 117.6301, 'Marie-Louise Meilleur',
* 117.5178, 'Violet Brown', 117.3753, 'Emma Morano',
* 117.2219, 'Chiyo Miyako', 117.0740, 'Misao Okawa');
*
* $redis->zRevRangeByScore('oldest-people', 122, 119);
* $redis->zRevRangeByScore('oldest-people', 'inf', 118);
* $redis->zRevRangeByScore('oldest-people', '117.5', '-inf', ['LIMIT' => [0, 1]]);
*/
public function zRevRangeByScore(string $key, string $start, string $end, array $options = []) {}
/**
* Returns a lexigraphical range of members in a sorted set, assuming the members have the same score. The
* min and max values are required to start with '(' (exclusive), '[' (inclusive), or be exactly the values
* '-' (negative inf) or '+' (positive inf). The command must be called with either three *or* five
* arguments or will return FALSE.
*
* @param string $key The ZSET you wish to run against.
* @param string $min The minimum alphanumeric value you wish to get.
* @param string $max The maximum alphanumeric value you wish to get.
* @param int $offset Optional argument if you wish to start somewhere other than the first element.
* @param int $count An optional count to limit the replies to (used in conjunction with offset)
*
* @return array|false|Redis Array containing the values in the specified range or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/zrangebylex
* @example
* <pre>
* foreach (array('a', 'b', 'c', 'd', 'e', 'f', 'g') as $char) {
* $redis->zAdd('key', $char);
* }
*
* $redis->zRangeByLex('key', '-', '[c'); // array('a', 'b', 'c')
* $redis->zRangeByLex('key', '-', '(c'); // array('a', 'b')
* $redis->zRangeByLex('key', '-', '[c'); // array('b', 'c')
* </pre>
*/
public function zRangeByLex(string $key, string $min, string $max, int $offset = -1, int $count = -1) {}
/**
* Retrieve the score of one or more members in a sorted set.
*
* @link https://redis.io/commands/zmscore
*
* @param string $key The sorted set
* @param mixed $member The first member to return the score from
* @param mixed $other_members One or more additional members to return the scores of.
*
* @return Redis|array|false An array of the scores of the requested elements.
*
* @example
* $redis->zAdd('zs', 0, 'zero', 1, 'one', 2, 'two', 3, 'three');
*
* $redis->zMScore('zs', 'zero', 'two');
* $redis->zMScore('zs', 'one', 'not-a-member');
*/
public function zMscore(string $key, string $member, string ...$other_members): array|false {}
/**
* Pop one or more of the highest scoring elements from a sorted set.
*
* @param string $key The sorted set to pop elements from.
* @param int|null $count An optional count of elements to pop.
*
* @return Redis|array|false All of the popped elements with scores or false on fialure.
*
* @link https://redis.io/commands/zpopmax
*
* @example
* $redis->zAdd('zs', 0, 'zero', 1, 'one', 2, 'two', 3, 'three');
*
* $redis->zPopMax('zs');
* $redis->zPopMax('zs', 2);.
*/
public function zPopMax(string $key, int $count = null): array|false {}
/**
* Pop one or more of the lowest scoring elements from a sorted set.
*
* @param string $key The sorted set to pop elements from.
* @param int|null $count An optional count of elements to pop.
*
* @return Redis|array|false The popped elements with their scores or false on failure.
*
* @link https://redis.io/commands/zpopmin
*
* @example
* $redis->zAdd('zs', 0, 'zero', 1, 'one', 2, 'two', 3, 'three');
*
* $redis->zPopMin('zs');
* $redis->zPopMin('zs', 2);
*/
public function zPopMin(string $key, int $count = null): array|false {}
/**
* Retrieve one or more random members from a Redis sorted set.
*
* @param string $key The sorted set to pull random members from.
* @param array|null $options One or more options that determine exactly how the command operates.
*
* OPTION TYPE MEANING
* 'COUNT' int The number of random members to return.
* 'WITHSCORES' bool Whether to return scores and members instead of
*
* @return Redis|string|array One ore more random elements.
*
* @see https://redis.io/commands/zrandmember
*
* @example $redis->zRandMember('zs', ['COUNT' => 2, 'WITHSCORES' => true]);
*/
public function zRandMember(string $key, array $options = null): string|array|false {}
/**
* List members of a Redis sorted set within a legographical range, in reverse order.
*
* @param string $key The sorted set to list
* @param string $min The maximum legographical element to include in the result.
* @param string $min The minimum lexographical element to include in the result.
* @param int $offset An option offset within the matching elements to start at.
* @param int $count An optional count to limit the replies to.
*
* @return false|array|Redis returns Redis if in multimode
*
* @throws RedisException
*
* @see zRangeByLex()
* @link https://redis.io/commands/zrevrangebylex
*
* @example
* $redis->zRevRangeByLex('captains', '[Q', '[J');
* $redis->zRevRangeByLex('captains', '[Q', '[J', 1, 2);
*/
public function zRevRangeByLex(string $key, string $min, string $max, int $offset = -1, int $count = -1) {}
/**
* Removes all elements in the sorted set stored at key between the lexicographical range specified by min and max.
* Applies when all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering.
*
* @param string $key The sorted set to remove elements from.
* @param string $min The start of the lexographical range to remove.
* @param string $max The end of the lexographical range to remove
*
* @return int|false|Redis The number of elements removed
*
* @link https://redis.io/commands/zremrangebylex
*
* @example
* $redis->zRemRangeByLex('zs', '[a', '(b');
* $redis->zRemRangeByLex('zs', '(banana', '(eggplant');
*/
public function zRemRangeByLex(string $key, string $min, string $max) {}
/**
* Returns the number of elements of the sorted set stored at the specified key which have
* scores in the range [start,end]. Adding a parenthesis before start or end excludes it
* from the range. +inf and -inf are also valid limits.
*
* @param string $key
* @param string $start
* @param string $end
*
* @return false|int|Redis the size of a corresponding zRangeByScore or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/zcount
* @example
* <pre>
* $redis->zAdd('key', 0, 'val0');
* $redis->zAdd('key', 2, 'val2');
* $redis->zAdd('key', 10, 'val10');
* $redis->zCount('key', 0, 3); // 2, corresponding to array('val0', 'val2')
* </pre>
*/
public function zCount($key, $start, $end) {}
/**
* Deletes the elements of the sorted set stored at the specified key which have scores in the range [start,end].
*
* @param string $key
* @param string $start double or "+inf" or "-inf" as a string
* @param string $end double or "+inf" or "-inf" as a string
*
* @return false|int|Redis The number of values deleted from the sorted set or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/zremrangebyscore
* @example
* <pre>
* $redis->zAdd('key', 0, 'val0');
* $redis->zAdd('key', 2, 'val2');
* $redis->zAdd('key', 10, 'val10');
* $redis->zRemRangeByScore('key', '0', '3'); // 2
* </pre>
*/
public function zRemRangeByScore($key, $start, $end) {}
/**
* @param string $key
* @param float $start
* @param float $end
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->zRemRangeByScore(%parametersList%)')]
public function zDeleteRangeByScore($key, $start, $end) {}
/**
* Deletes the elements of the sorted set stored at the specified key which have rank in the range [start,end].
*
* @param string $key
* @param int $start
* @param int $end
*
* @return false|int|Redis The number of values deleted from the sorted set or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/zremrangebyrank
* @example
* <pre>
* $redis->zAdd('key', 1, 'one');
* $redis->zAdd('key', 2, 'two');
* $redis->zAdd('key', 3, 'three');
* $redis->zRemRangeByRank('key', 0, 1); // 2
* $redis->zRange('key', 0, -1, array('withscores' => TRUE)); // array('three' => 3)
* </pre>
*/
public function zRemRangeByRank($key, $start, $end) {}
/**
* @link https://redis.io/commands/zremrangebyscore
*
* @param string $key
* @param int $start
* @param int $end
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->zRemRangeByRank(%parametersList%)')]
public function zDeleteRangeByRank($key, $start, $end) {}
/**
* Returns the cardinality of an ordered set.
*
* @param string $key
*
* @return false|int|Redis the set's cardinality or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/zsize
* @example
* <pre>
* $redis->zAdd('key', 0, 'val0');
* $redis->zAdd('key', 2, 'val2');
* $redis->zAdd('key', 10, 'val10');
* $redis->zCard('key'); // 3
* </pre>
*/
public function zCard($key) {}
/**
* Given one or more sorted set key names, return every element that is in the first
* set but not any of the others.
*
* @param array $keys One ore more sorted sets.
* @param array|null $options An array which can contain ['WITHSCORES' => true] if you want Redis to return members and scores.
*
* @return Redis|array|false An array of members or false on failure.
*
* @link https://redis.io/commands/zdiff
*
* @example
* $redis->zAdd('primes', 1, 'one', 3, 'three', 5, 'five');
* $redis->zAdd('evens', 2, 'two', 4, 'four');
* $redis->zAdd('mod3', 3, 'three', 6, 'six');
*
* $redis->zDiff(['primes', 'evens', 'mod3']);
*/
public function zdiff(array $keys, array $options = null): array|false {}
/**
* @param string $key
* @return false|int|Redis returns Redis if in multimode
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->zCard(%parametersList%)')]
public function zSize($key) {}
/**
* Returns the score of a given member in the specified sorted set.
*
* @param string $key The sorted set to query.
* @param mixed $member The member we wish to query.
*
* @return float|bool|Redis false if member or key not exists or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/zscore
* @example
* <pre>
* $redis->zAdd('key', 2.5, 'val2');
* $redis->zScore('key', 'val2'); // 2.5
* </pre>
*/
public function zScore($key, $member) {}
/**
* Returns the rank of a given member in the specified sorted set, starting at 0 for the item
* with the smallest score. zRevRank starts at 0 for the item with the largest score.
*
* @param string $key
* @param mixed $member
*
* @return int|false|Redis the item's score, or false if key or member is not exists or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/zrank
* @example
* <pre>
* $redis->del('z');
* $redis->zAdd('key', 1, 'one');
* $redis->zAdd('key', 2, 'two');
* $redis->zRank('key', 'one'); // 0
* $redis->zRank('key', 'two'); // 1
* $redis->zRevRank('key', 'one'); // 1
* $redis->zRevRank('key', 'two'); // 0
* </pre>
*/
public function zRank($key, $member) {}
/**
* @see zRank()
* @param string $key
* @param string|mixed $member
*
* @return int|false|Redis the item's score, false - if key or member is not exists or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/zrevrank
*/
public function zRevRank($key, $member) {}
/**
* Increments the score of a member from a sorted set by a given amount.
*
* @param string $key
* @param float $value (double) value that will be added to the member's score
* @param mixed $member
*
* @return float|Redis the new value or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/zincrby
* @example
* <pre>
* $redis->del('key');
* $redis->zIncrBy('key', 2.5, 'member1'); // key or member1 didn't exist, so member1's score is to 0
* // before the increment and now has the value 2.5
* $redis->zIncrBy('key', 1, 'member1'); // 3.5
* </pre>
*/
public function zIncrBy($key, $value, $member) {}
/**
* Creates an union of sorted sets given in second argument.
* The result of the union will be stored in the sorted set defined by the first argument.
* The third optionnel argument defines weights to apply to the sorted sets in input.
* In this case, the weights will be multiplied by the score of each element in the sorted set
* before applying the aggregation. The forth argument defines the AGGREGATE option which
* specify how the results of the union are aggregated.
*
* @param string $output
* @param array $zSetKeys
* @param null|array $weights
* @param string|null $aggregateFunction Either "SUM", "MIN", or "MAX": defines the behaviour to use on
* duplicate entries during the zUnionStore
*
* @return false|int|Redis The number of values in the new sorted set or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/zunionstore
* @example
* <pre>
* $redis->del('k1');
* $redis->del('k2');
* $redis->del('k3');
* $redis->del('ko1');
* $redis->del('ko2');
* $redis->del('ko3');
*
* $redis->zAdd('k1', 0, 'val0');
* $redis->zAdd('k1', 1, 'val1');
*
* $redis->zAdd('k2', 2, 'val2');
* $redis->zAdd('k2', 3, 'val3');
*
* $redis->zUnionStore('ko1', array('k1', 'k2')); // 4, 'ko1' => array('val0', 'val1', 'val2', 'val3')
*
* // Weighted zUnionStore
* $redis->zUnionStore('ko2', array('k1', 'k2'), array(1, 1)); // 4, 'ko2' => array('val0', 'val1', 'val2', 'val3')
* $redis->zUnionStore('ko3', array('k1', 'k2'), array(5, 1)); // 4, 'ko3' => array('val0', 'val2', 'val3', 'val1')
* </pre>
*/
public function zUnionStore($output, $zSetKeys, ?array $weights = null, $aggregateFunction = null) {}
/**
* @param string $Output
* @param array $ZSetKeys
* @param array|null $Weights
* @param string $aggregateFunction
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->zUnionStore(%parametersList%)')]
public function zUnion($Output, $ZSetKeys, array $Weights = null, $aggregateFunction = 'SUM') {}
/**
* Creates an intersection of sorted sets given in second argument.
* The result of the union will be stored in the sorted set defined by the first argument.
* The third optional argument defines weights to apply to the sorted sets in input.
* In this case, the weights will be multiplied by the score of each element in the sorted set
* before applying the aggregation. The forth argument defines the AGGREGATE option which
* specify how the results of the union are aggregated.
*
* @param string $output
* @param array $zSetKeys
* @param null|array $weights
* @param string|null $aggregateFunction Either "SUM", "MIN", or "MAX":
* defines the behaviour to use on duplicate entries during the zInterStore.
*
* @return false|int|Redis The number of values in the new sorted set or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/zinterstore
* @example
* <pre>
* $redis->del('k1');
* $redis->del('k2');
* $redis->del('k3');
*
* $redis->del('ko1');
* $redis->del('ko2');
* $redis->del('ko3');
* $redis->del('ko4');
*
* $redis->zAdd('k1', 0, 'val0');
* $redis->zAdd('k1', 1, 'val1');
* $redis->zAdd('k1', 3, 'val3');
*
* $redis->zAdd('k2', 2, 'val1');
* $redis->zAdd('k2', 3, 'val3');
*
* $redis->zInterStore('ko1', array('k1', 'k2')); // 2, 'ko1' => array('val1', 'val3')
* $redis->zInterStore('ko2', array('k1', 'k2'), array(1, 1)); // 2, 'ko2' => array('val1', 'val3')
*
* // Weighted zInterStore
* $redis->zInterStore('ko3', array('k1', 'k2'), array(1, 5), 'min'); // 2, 'ko3' => array('val1', 'val3')
* $redis->zInterStore('ko4', array('k1', 'k2'), array(1, 5), 'max'); // 2, 'ko4' => array('val3', 'val1')
* </pre>
*/
public function zInterStore($output, $zSetKeys, array $weights = null, $aggregateFunction = null) {}
/**
* @param $Output
* @param $ZSetKeys
* @param array|null $Weights
* @param string $aggregateFunction
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->zInterStore(%parametersList%)')]
public function zInter($Output, $ZSetKeys, array $Weights = null, $aggregateFunction = 'SUM') {}
/**
* Scan a sorted set for members, with optional pattern and count
*
* @param string $key String, the set to scan.
* @param int|null &$iterator Long (reference), initialized to NULL.
* @param string $pattern String (optional), the pattern to match.
* @param int $count How many keys to return per iteration (Redis might return a different number).
*
* @return array|false|Redis PHPRedis will return matching keys from Redis, or FALSE when iteration is complete or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/zscan
* @example
* <pre>
* $iterator = null;
* while ($members = $redis-zscan('zset', $iterator)) {
* foreach ($members as $member => $score) {
* echo $member . ' => ' . $score . PHP_EOL;
* }
* }
* </pre>
*/
public function zScan($key, &$iterator, $pattern = null, $count = 0) {}
/**
* Block until Redis can pop the highest or lowest scoring members from one or more ZSETs.
* There are two commands (BZPOPMIN and BZPOPMAX for popping the lowest and highest scoring elements respectively.)
*
* @param string|array $key_or_keys Either a string key or an array of one or more keys.
* @param string|int|array $timeout_or_key If the previous argument was an array, this argument must be a timeout value. Otherwise it could also be another key.
* @param mixed ...$extra_args Can consist of additional keys, until the last argument which needs to be a timeout.
*
* @return false|array|Redis Either an array with the key member and score of the highest or lowest element or an empty array or Redis if in multimode
* if the timeout was reached without an element to pop.
*
* @throws RedisException
*
* @since >= 5.0
* @link https://redis.io/commands/bzpopmax
* @example
* <pre>
* // Wait up to 5 seconds to pop the *highest* scoring member from sets `zs1` and `zs2`
* $redis->bzPopMax(['zs1', 'zs2'], 5);
* $redis->bzPopMax('zs1', 'zs2', 5);
* </pre>
*/
public function bzPopMax($key_or_keys, $timeout_or_key, ...$extra_args) {}
/**
* POP the minimum scoring element off of one or more sorted sets, blocking up to a specified timeout if no elements are available.
*
* @param string|array $key_or_keys Either a string key or an array of one or more keys.
* @param string|int|array $timeout_or_key If the previous argument was an array, this argument must be a timeout value. Otherwise it could also be another key.
* @param mixed ...$extra_args Can consist of additional keys, until the last argument which needs to be a timeout.
*
* @return false|array|Redis Either an array with the key member and score of the highest or lowest element or an empty array or Redis if in multimode
* if the timeout was reached without an element to pop.
*
* @throws RedisException
*
* @see bzPopMax
* @since >= 5.0
* @link https://redis.io/commands/bzpopmin
*
* @example
* <pre>
* // Wait up to 5 seconds to pop the *lowest* scoring member from sets `zs1` and `zs2`.
* $redis->bzPopMin(['zs1', 'zs2'], 5);
* $redis->bzPopMin('zs1', 'zs2', 5);
* </pre>
*/
public function bzPopMin($key_or_keys, $timeout_or_key, ...$extra_args) {}
/**
* Adds a value to the hash stored at key. If this value is already in the hash, FALSE is returned.
*
* @param string $key
* @param string $hashKey
* @param mixed $value
*
* @return int|bool|Redis returns Redis if in multimode
* - 1 if value didn't exist and was added successfully,
* - 0 if the value was already present and was replaced, FALSE if there was an error.
*
* @throws RedisException
*
* @link https://redis.io/commands/hset
* @example
* <pre>
* $redis->del('h')
* $redis->hSet('h', 'key1', 'hello'); // 1, 'key1' => 'hello' in the hash at "h"
* $redis->hGet('h', 'key1'); // returns "hello"
*
* $redis->hSet('h', 'key1', 'plop'); // 0, value was replaced.
* $redis->hGet('h', 'key1'); // returns "plop"
* </pre>
*/
public function hSet($key, $hashKey, $value) {}
/**
* Adds a value to the hash stored at key only if this field isn't already in the hash.
*
* @param string $key
* @param string $hashKey
* @param string $value
*
* @return bool|Redis TRUE if the field was set, FALSE if it was already present or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/hsetnx
* @example
* <pre>
* $redis->del('h')
* $redis->hSetNx('h', 'key1', 'hello'); // TRUE, 'key1' => 'hello' in the hash at "h"
* $redis->hSetNx('h', 'key1', 'world'); // FALSE, 'key1' => 'hello' in the hash at "h". No change since the field
* wasn't replaced.
* </pre>
*/
public function hSetNx($key, $hashKey, $value) {}
/**
* Gets a value from the hash stored at key.
* If the hash table doesn't exist, or the key doesn't exist, FALSE is returned.
*
* @param string $key
* @param string $hashKey
*
* @return string|false|Redis The value, if the command executed successfully BOOL FALSE in case of failure or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/hget
*/
public function hGet($key, $hashKey) {}
/**
* Returns the length of a hash, in number of items
*
* @param string $key
*
* @return int|false|Redis the number of items in a hash, FALSE if the key doesn't exist or isn't a hash or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/hlen
* @example
* <pre>
* $redis->del('h')
* $redis->hSet('h', 'key1', 'hello');
* $redis->hSet('h', 'key2', 'plop');
* $redis->hLen('h'); // returns 2
* </pre>
*/
public function hLen($key) {}
/**
* Removes a values from the hash stored at key.
* If the hash table doesn't exist, or the key doesn't exist, FALSE is returned.
*
* @param string $key
* @param string $hashKey1
* @param string ...$otherHashKeys
*
* @return int|bool|Redis Number of deleted fields or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/hdel
* @example
* <pre>
* $redis->hMSet('h',
* array(
* 'f1' => 'v1',
* 'f2' => 'v2',
* 'f3' => 'v3',
* 'f4' => 'v4',
* ));
*
* var_dump( $redis->hDel('h', 'f1') ); // int(1)
* var_dump( $redis->hDel('h', 'f2', 'f3') ); // int(2)
* s
* var_dump( $redis->hGetAll('h') );
* //// Output:
* // array(1) {
* // ["f4"]=> string(2) "v4"
* // }
* </pre>
*/
public function hDel($key, $hashKey1, ...$otherHashKeys) {}
/**
* Returns the keys in a hash, as an array of strings.
*
* @param string $key
*
* @return array|false|Redis An array of elements, the keys of the hash. This works like PHP's array_keys() or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/hkeys
* @example
* <pre>
* $redis->del('h');
* $redis->hSet('h', 'a', 'x');
* $redis->hSet('h', 'b', 'y');
* $redis->hSet('h', 'c', 'z');
* $redis->hSet('h', 'd', 't');
* var_dump($redis->hKeys('h'));
*
* // Output:
* // array(4) {
* // [0]=>
* // string(1) "a"
* // [1]=>
* // string(1) "b"
* // [2]=>
* // string(1) "c"
* // [3]=>
* // string(1) "d"
* // }
* // The order is random and corresponds to redis' own internal representation of the set structure.
* </pre>
*/
public function hKeys($key) {}
/**
* Returns the values in a hash, as an array of strings.
*
* @param string $key
*
* @return array|false|Redis An array of elements, the values of the hash. This works like PHP's array_values() or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/hvals
* @example
* <pre>
* $redis->del('h');
* $redis->hSet('h', 'a', 'x');
* $redis->hSet('h', 'b', 'y');
* $redis->hSet('h', 'c', 'z');
* $redis->hSet('h', 'd', 't');
* var_dump($redis->hVals('h'));
*
* // Output
* // array(4) {
* // [0]=>
* // string(1) "x"
* // [1]=>
* // string(1) "y"
* // [2]=>
* // string(1) "z"
* // [3]=>
* // string(1) "t"
* // }
* // The order is random and corresponds to redis' own internal representation of the set structure.
* </pre>
*/
public function hVals($key) {}
/**
* Returns the whole hash, as an array of strings indexed by strings.
*
* @param string $key
*
* @return array|false|Redis An array of elements, the contents of the hash or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/hgetall
* @example
* <pre>
* $redis->del('h');
* $redis->hSet('h', 'a', 'x');
* $redis->hSet('h', 'b', 'y');
* $redis->hSet('h', 'c', 'z');
* $redis->hSet('h', 'd', 't');
* var_dump($redis->hGetAll('h'));
*
* // Output:
* // array(4) {
* // ["a"]=>
* // string(1) "x"
* // ["b"]=>
* // string(1) "y"
* // ["c"]=>
* // string(1) "z"
* // ["d"]=>
* // string(1) "t"
* // }
* // The order is random and corresponds to redis' own internal representation of the set structure.
* </pre>
*/
public function hGetAll($key) {}
/**
* Verify if the specified member exists in a key.
*
* @param string $key
* @param string $hashKey
*
* @return bool|Redis If the member exists in the hash table, return TRUE, otherwise return FALSE or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/hexists
* @example
* <pre>
* $redis->hSet('h', 'a', 'x');
* $redis->hExists('h', 'a'); // TRUE
* $redis->hExists('h', 'NonExistingKey'); // FALSE
* </pre>
*/
public function hExists($key, $hashKey) {}
/**
* Increments the value of a member from a hash by a given amount.
*
* @param string $key
* @param string $hashKey
* @param int $value (integer) value that will be added to the member's value
*
* @return false|int|Redis the new value or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/hincrby
* @example
* <pre>
* $redis->del('h');
* $redis->hIncrBy('h', 'x', 2); // returns 2: h[x] = 2 now.
* $redis->hIncrBy('h', 'x', 1); // h[x] ← 2 + 1. Returns 3
* </pre>
*/
public function hIncrBy($key, $hashKey, $value) {}
/**
* Increment the float value of a hash field by the given amount
*
* @param string $key
* @param string $field
* @param float $increment
*
* @return float|false|Redis returns Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/hincrbyfloat
* @example
* <pre>
* $redis = new Redis();
* $redis->connect('127.0.0.1');
* $redis->hset('h', 'float', 3);
* $redis->hset('h', 'int', 3);
* var_dump( $redis->hIncrByFloat('h', 'float', 1.5) ); // float(4.5)
*
* var_dump( $redis->hGetAll('h') );
*
* // Output
* array(2) {
* ["float"]=>
* string(3) "4.5"
* ["int"]=>
* string(1) "3"
* }
* </pre>
*/
public function hIncrByFloat($key, $field, $increment) {}
/**
* Fills in a whole hash. Non-string values are converted to string, using the standard (string) cast.
* NULL values are stored as empty strings
*
* @param string $key
* @param array $hashKeys key → value array
*
* @return bool|Redis returns Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/hmset
* @example
* <pre>
* $redis->del('user:1');
* $redis->hMSet('user:1', array('name' => 'Joe', 'salary' => 2000));
* $redis->hIncrBy('user:1', 'salary', 100); // Joe earns 100 more now.
* </pre>
*/
public function hMSet($key, $hashKeys) {}
/**
* Retrieve the values associated to the specified fields in the hash.
*
* @param string $key
* @param array $hashKeys
*
* @return array|false|Redis Array An array of elements, the values of the specified fields in the hash, or Redis if in multimode
* with the hash keys as array keys.
*
* @throws RedisException
*
* @link https://redis.io/commands/hmget
* @example
* <pre>
* $redis->del('h');
* $redis->hSet('h', 'field1', 'value1');
* $redis->hSet('h', 'field2', 'value2');
* $redis->hMGet('h', array('field1', 'field2')); // returns array('field1' => 'value1', 'field2' => 'value2')
* </pre>
*/
public function hMGet($key, $hashKeys) {}
/**
* Scan a HASH value for members, with an optional pattern and count.
*
* @param string $key
* @param int|null ?$iterator The scan iterator, which should be initialized to NULL before the first call.
* @param string $pattern Optional pattern to match against.
* @param int $count How many keys to return in a go (only a sugestion to Redis).
*
* @return array|bool|Redis An array of members that match our pattern or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/hscan
* @example
* <pre>
* $redis->del('big-hash');
*
* for ($i = 0; $i < 1000; $i++) {
* $fields["field:$i"] = "value:$i";
* }
*
* $redis->hMSet('big-hash', $fields);
*
* $it = NULL;
*
* do {
* // Scan the hash but limit it to fields that match '*:1?3'
* $fields = $redis->hScan('big-hash', $it, '*:1?3');
*
* foreach ($fields as $field => $value) {
* echo "[$field] => $value\n";
* }
* } while ($it != 0);
* </pre>
*/
public function hScan($key, &$iterator, $pattern = null, $count = 0) {}
/**
* Get the string length of the value associated with field in the hash stored at key
*
* @param string $key
* @param string $field
*
* @return false|int|Redis the string length of the value associated with field, or zero when field is not present in the hash or Redis if in multimode
* or key does not exist at all.
*
* @throws RedisException
*
* @link https://redis.io/commands/hstrlen
* @since >= 3.2
*
* @example
* $redis->del('hash');
* $redis->hMSet('hash', ['50bytes' => str_repeat('a', 50)]);
* $redis->hStrLen('hash', '50bytes');
*/
public function hStrLen(string $key, string $field) {}
/**
* Add one or more geospatial items to the specified key.
* This function must be called with at least one longitude, latitude, member triplet.
*
* @param string $key
* @param float $longitude
* @param float $latitude
* @param string $member
* @param mixed $other_triples_and_options You can continue to pass longitude, lattitude, and member arguments to add as many members
* as you wish. Optionally, the final argument may be a string with options for the command
*
* @return false|int|Redis The number of elements added to the geospatial key or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/geoadd
* @since >= 3.2
*
* @example
* <pre>
* $redis->del("myplaces");
*
* // Since the key will be new, $result will be 2
* $result = $redis->geoAdd(
* "myplaces",
* -122.431, 37.773, "San Francisco",
* -157.858, 21.315, "Honolulu"
* ); // 2
*
* $redis->geoAdd('cities', -121.837478, 39.728494, 'Chico', ['XX', 'CH']);
* $redis->geoAdd('cities', -121.8374, 39.7284, 'Chico', -122.03218, 37.322, 'Cupertino');
* </pre>
*/
public function geoAdd($key, $longitude, $latitude, $member, ...$other_triples_and_options) {}
/**
* Retrieve Geohash strings for one or more elements of a geospatial index.
*
* @param string $key
* @param string ...$member variadic list of members
*
* @return false|array|Redis One or more Redis Geohash encoded strings or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/geohash
* @since >= 3.2
*
* @example
* <pre>
* $redis->geoAdd("hawaii", -157.858, 21.306, "Honolulu", -156.331, 20.798, "Maui");
* $hashes = $redis->geoHash("hawaii", "Honolulu", "Maui");
* var_dump($hashes);
* // Output: array(2) {
* // [0]=>
* // string(11) "87z9pyek3y0"
* // [1]=>
* // string(11) "8e8y6d5jps0"
* // }
* </pre>
*/
public function geoHash($key, ...$member) {}
/**
* Return longitude, latitude positions for each requested member.
*
* @param string $key
* @param string ...$member
* @return array|Redis One or more longitude/latitude positions or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/geopos
* @since >= 3.2
*
* @example
* <pre>
* $redis->geoAdd("hawaii", -157.858, 21.306, "Honolulu", -156.331, 20.798, "Maui");
* $positions = $redis->geoPos("hawaii", "Honolulu", "Maui");
* var_dump($positions);
*
* // Output:
* array(2) {
* [0]=> array(2) {
* [0]=> string(22) "-157.85800248384475708"
* [1]=> string(19) "21.3060004581273077"
* }
* [1]=> array(2) {
* [0]=> string(22) "-156.33099943399429321"
* [1]=> string(20) "20.79799924753607598"
* }
* }
* </pre>
*/
public function geoPos(string $key, string ...$member) {}
/**
* Search a geospacial sorted set for members in various ways.
*
* @param string $key The set to query.
* @param array|string $position Either a two element array with longitude and lattitude, or a string representing a member of the set.
* @param array|int|float $shape Either a number representine the radius of a circle to search, or
* a two element array representing the width and height of a box to search.
* @param string $unit The unit of our shape. See geodist() for possible units.
* @param array $options See georadius() for options. Note that the `STORE` options are not allowed for this command.
*
* @return mixed[]
*/
public function geosearch(string $key, array|string $position, array|int|float $shape, string $unit, array $options = []): array|false {}
/**
* Search a geospacial sorted set for members within a given area or range, storing the results into
* a new set.
*
* @param string $dst The destination where results will be stored.
* @param string $src The key to query.
* @param array|string $position Either a two element array with longitude and lattitude, or a string representing a member of the set.
* @param array|int|float $shape Either a number representine the radius of a circle to search, or
* a two element array representing the width and height of a box to search.
* @param string $unit The unit of our shape. See geoDist for possible units.
* @param array $options
* <code>
* $options = [
* 'ASC' | 'DESC', # The sort order of returned members
* 'WITHDIST' # Also store distances.
* # Limit to N returned members. Optionally a two element array may be
* # passed as the `LIMIT` argument, and the `ANY` argument.
* 'COUNT' => [<int>], or [<int>, <bool>]
* ];
* </code>
*
* @return mixed[]|int|true|Redis
*/
public function geosearchstore(string $dst, string $src, array|string $position, array|int|float $shape, string $unit, array $options = []): array|false {}
/**
* Return the distance between two members in a geospatial set.
*
* If units are passed it must be one of the following values:
* - 'm' => Meters
* - 'km' => Kilometers
* - 'mi' => Miles
* - 'ft' => Feet
*
* @param string $key
* @param string $member1
* @param string $member2
* @param string|null $unit Which unit to use when computing distance, defaulting to meters. M - meters, KM - kilometers, FT - feet, MI - miles
*
* @return float|Redis The distance between the two passed members in the units requested (meters by default) or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/geodist
* @since >= 3.2
*
* @example
* <pre>
* $redis->geoAdd("hawaii", -157.858, 21.306, "Honolulu", -156.331, 20.798, "Maui");
*
* $meters = $redis->geoDist("hawaii", "Honolulu", "Maui");
* $kilometers = $redis->geoDist("hawaii", "Honolulu", "Maui", 'km');
* $miles = $redis->geoDist("hawaii", "Honolulu", "Maui", 'mi');
* $feet = $redis->geoDist("hawaii", "Honolulu", "Maui", 'ft');
*
* echo "Distance between Honolulu and Maui:\n";
* echo " meters : $meters\n";
* echo " kilometers: $kilometers\n";
* echo " miles : $miles\n";
* echo " feet : $feet\n";
*
* // Bad unit
* $inches = $redis->geoDist("hawaii", "Honolulu", "Maui", 'in');
* echo "Invalid unit returned:\n";
* var_dump($inches);
*
* // Output
* Distance between Honolulu and Maui:
* meters : 168275.204
* kilometers: 168.2752
* miles : 104.5616
* feet : 552084.0028
* Invalid unit returned:
* bool(false)
* </pre>
*/
public function geoDist($key, $member1, $member2, $unit = null) {}
/**
* Return members of a set with geospatial information that are within the radius specified by the caller.
*
* @param $key
* @param $longitude
* @param $latitude
* @param $radius
* @param $unit
* @param array|null $options
* <pre>
* |Key |Value |Description |
* |------------|---------------|---------------------------------------------------|
* |COUNT |integer > 0 |Limit how many results are returned |
* | |WITHCOORD |Return longitude and latitude of matching members |
* | |WITHDIST |Return the distance from the center |
* | |WITHHASH |Return the raw geohash-encoded score |
* | |ASC |Sort results in ascending order |
* | |DESC |Sort results in descending order |
* |STORE |key |Store results in key |
* |STOREDIST |key |Store the results as distances in key |
* </pre>
* Note: It doesn't make sense to pass both ASC and DESC options but if both are passed
* the last one passed will be used.
* Note: When using STORE[DIST] in Redis Cluster, the store key must has to the same slot as
* the query key or you will get a CROSSLOT error.
* @return mixed|Redis When no STORE option is passed, this function returns an array of results or Redis if in multimode
* If it is passed this function returns the number of stored entries.
*
* @throws RedisException
*
* @link https://redis.io/commands/georadius
* @since >= 3.2
* @example
* <pre>
* // Add some cities
* $redis->geoAdd("hawaii", -157.858, 21.306, "Honolulu", -156.331, 20.798, "Maui");
*
* echo "Within 300 miles of Honolulu:\n";
* var_dump($redis->geoRadius("hawaii", -157.858, 21.306, 300, 'mi'));
*
* echo "\nWithin 300 miles of Honolulu with distances:\n";
* $options = ['WITHDIST'];
* var_dump($redis->geoRadius("hawaii", -157.858, 21.306, 300, 'mi', $options));
*
* echo "\nFirst result within 300 miles of Honolulu with distances:\n";
* $options['count'] = 1;
* var_dump($redis->geoRadius("hawaii", -157.858, 21.306, 300, 'mi', $options));
*
* echo "\nFirst result within 300 miles of Honolulu with distances in descending sort order:\n";
* $options[] = 'DESC';
* var_dump($redis->geoRadius("hawaii", -157.858, 21.306, 300, 'mi', $options));
*
* // Output
* Within 300 miles of Honolulu:
* array(2) {
* [0]=> string(8) "Honolulu"
* [1]=> string(4) "Maui"
* }
*
* Within 300 miles of Honolulu with distances:
* array(2) {
* [0]=>
* array(2) {
* [0]=>
* string(8) "Honolulu"
* [1]=>
* string(6) "0.0002"
* }
* [1]=>
* array(2) {
* [0]=>
* string(4) "Maui"
* [1]=>
* string(8) "104.5615"
* }
* }
*
* First result within 300 miles of Honolulu with distances:
* array(1) {
* [0]=>
* array(2) {
* [0]=>
* string(8) "Honolulu"
* [1]=>
* string(6) "0.0002"
* }
* }
*
* First result within 300 miles of Honolulu with distances in descending sort order:
* array(1) {
* [0]=>
* array(2) {
* [0]=>
* string(4) "Maui"
* [1]=>
* string(8) "104.5615"
* }
* }
* </pre>
*/
public function geoRadius($key, $longitude, $latitude, $radius, $unit, array $options = []) {}
/**
* This method is identical to geoRadius except that instead of passing a longitude and latitude as the "source"
* you pass an existing member in the geospatial set
*
* @param string $key
* @param string $member
* @param $radius
* @param $units
* @param array|null $options see georadius
*
* @return mixed|Redis The zero or more entries that are close enough to the member given the distance and radius specified or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/georadiusbymember
* @since >= 3.2
* @see georadius
* @example
* <pre>
* $redis->geoAdd("hawaii", -157.858, 21.306, "Honolulu", -156.331, 20.798, "Maui");
*
* echo "Within 300 miles of Honolulu:\n";
* var_dump($redis->geoRadiusByMember("hawaii", "Honolulu", 300, 'mi'));
*
* echo "\nFirst match within 300 miles of Honolulu:\n";
* var_dump($redis->geoRadiusByMember("hawaii", "Honolulu", 300, 'mi', ['count' => 1]));
*
* // Output
* Within 300 miles of Honolulu:
* array(2) {
* [0]=> string(8) "Honolulu"
* [1]=> string(4) "Maui"
* }
*
* First match within 300 miles of Honolulu:
* array(1) {
* [0]=> string(8) "Honolulu"
* }
* </pre>
*/
public function geoRadiusByMember($key, $member, $radius, $units, array $options = []) {}
/**
* Execute the Redis CONFIG command in a variety of ways.
*
* @param string $operation Operations that PhpRedis supports: RESETSTAT, REWRITE, GET, and SET.
* @param array|string|null $key_or_settings One or more keys or values.
* @param string|null $value The value if this is a `CONFIG SET` operation.
*
* @return mixed|Redis Associative array for `GET`, key -> value or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/config-get
* @example
* <pre>
* $redis->config('GET', 'timeout');
* $redis->config('GET', ['timeout', 'databases']);
* $redis->config('SET', 'timeout', 30);
* $redis->config('SET', ['timeout' => 30, 'loglevel' => 'warning']);
* </pre>
*/
public function config($operation, $key_or_settings = null, $value = null) {}
/**
* Evaluate a LUA script serverside
*
* @param string $script
* @param array $args
* @param int $numKeys
*
* @return mixed|Redis What is returned depends on what the LUA script itself returns, which could be a scalar value or Redis if in multimode
* (int/string), or an array. Arrays that are returned can also contain other arrays, if that's how it was set up in
* your LUA script. If there is an error executing the LUA script, the getLastError() function can tell you the
* message that came back from Redis (e.g. compile error).
*
* @throws RedisException
*
* @link https://redis.io/commands/eval
* @example
* <pre>
* $redis->eval("return 1"); // Returns an integer: 1
* $redis->eval("return {1,2,3}"); // Returns Array(1,2,3)
* $redis->del('mylist');
* $redis->rpush('mylist','a');
* $redis->rpush('mylist','b');
* $redis->rpush('mylist','c');
* // Nested response: Array(1,2,3,Array('a','b','c'));
* $redis->eval("return {1,2,3,redis.call('lrange','mylist',0,-1)}}");
* </pre>
*/
public function eval($script, $args = [], $numKeys = 0) {}
/**
* @param string $script
* @param array $args
* @param int $numKeys
* @return mixed|Redis @see eval() , returns Redis if in multimode
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->eval(%parametersList%)')]
public function evaluate($script, $args = [], $numKeys = 0) {}
/**
* Evaluate a LUA script serverside, from the SHA1 hash of the script instead of the script itself.
* In order to run this command Redis will have to have already loaded the script, either by running it or via
* the SCRIPT LOAD command.
*
* @param string $scriptSha
* @param array $args
* @param int $numKeys
*
* @return mixed|Redis @see eval() , returns Redis if in multimode
*
* @throws RedisException
*
* @see eval()
* @link https://redis.io/commands/evalsha
* @example
* <pre>
* $script = 'return 1';
* $sha = $redis->script('load', $script);
* $redis->evalSha($sha); // Returns 1
* </pre>
*/
public function evalSha($scriptSha, $args = [], $numKeys = 0) {}
/**
* @param string $scriptSha
* @param array $args
* @param int $numKeys
*
* @throws RedisException
*/
#[Deprecated(replacement: '%class%->evalSha(%parametersList%)')]
public function evaluateSha($scriptSha, $args = [], $numKeys = 0) {}
/**
* Execute the Redis SCRIPT command to perform various operations on the scripting subsystem.
* @param string $command load | flush | kill | exists
* @param mixed ...$script
*
* @return mixed|Redis This command returns various things depending on the specific operation executed. Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/script-load
* @link https://redis.io/commands/script-kill
* @link https://redis.io/commands/script-flush
* @link https://redis.io/commands/script-exists
* @example
* <pre>
* $redis->script('load', $script);
* $redis->script('flush');
* $redis->script('kill');
* $redis->script('exists', $script1, [$script2, $script3, ...]);
* </pre>
*
* SCRIPT LOAD will return the SHA1 hash of the passed script on success, and FALSE on failure.
* SCRIPT FLUSH should always return TRUE
* SCRIPT KILL will return true if a script was able to be killed and false if not
* SCRIPT EXISTS will return an array with TRUE or FALSE for each passed script
*/
public function script($command, ...$script) {}
/**
* The last error message (if any)
*
* @return string|null A string with the last returned script based error message, or NULL if there is no error
*
* @throws RedisException
*
* @example
* <pre>
* $redis->eval('this-is-not-lua');
* $err = $redis->getLastError();
* // "ERR Error compiling script (new function): user_script:1: '=' expected near '-'"
* </pre>
*/
public function getLastError() {}
/**
* Clear the last error message
*
* @return bool This should always return true or throw an exception if we're not connected.
*
* @throws RedisException
*
* @example
* <pre>
* $redis->set('x', 'a');
* $redis->incr('x');
* $err = $redis->getLastError();
* // "ERR value is not an integer or out of range"
* $redis->clearLastError();
* $err = $redis->getLastError();
* // NULL
* </pre>
*/
public function clearLastError() {}
/**
* Issue the CLIENT command with various arguments.
* The Redis CLIENT command can be used in four ways:
* - CLIENT LIST
* - CLIENT GETNAME
* - CLIENT SETNAME [name]
* - CLIENT KILL [ip:port]
*
* @param string $command
* @param mixed ...$args
* @return mixed This will vary depending on which client command was executed:
* - CLIENT LIST will return an array of arrays with client information.
* - CLIENT GETNAME will return the client name or false if none has been set
* - CLIENT SETNAME will return true if it can be set and false if not
* - CLIENT KILL will return true if the client can be killed, and false if not
*
* @throws RedisException
*
* Note: phpredis will attempt to reconnect so you can actually kill your own connection but may not notice losing it!
*
* @link https://redis.io/commands/client-list
* @link https://redis.io/commands/client-getname
* @link https://redis.io/commands/client-setname
* @link https://redis.io/commands/client-kill
*
* @example
* <pre>
* $redis->client('list'); // Get a list of clients
* $redis->client('getname'); // Get the name of the current connection
* $redis->client('setname', 'somename'); // Set the name of the current connection
* $redis->client('kill', <ip:port>); // Kill the process at ip:port
* </pre>
*/
public function client($command, ...$args) {}
/**
* A utility method to prefix the value with the prefix setting for phpredis.
*
* @param string $value The value you wish to prefix
*
* @return string If a prefix is set up, the value now prefixed
* If there is no prefix, the value will be returned unchanged.
*
* @throws RedisException
*
* @example
* <pre>
* $redis->setOption(Redis::OPT_PREFIX, 'my-prefix:');
* $redis->_prefix('my-value'); // Will return 'my-prefix:my-value'
* </pre>
*/
public function _prefix($value) {}
/**
* A utility method to unserialize data with whatever serializer is set up. If there is no serializer set, the
* value will be returned unchanged. If there is a serializer set up, and the data passed in is malformed, an
* exception will be thrown. This can be useful if phpredis is serializing values, and you return something from
* redis in a LUA script that is serialized.
*
* @param string $value The value to be unserialized
*
* @return mixed
* @example
* <pre>
* $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP);
* $redis->_unserialize('a:3:{i:0;i:1;i:1;i:2;i:2;i:3;}'); // Will return Array(1,2,3)
* </pre>
*/
public function _unserialize($value) {}
/**
* A utility method to serialize values manually. This method allows you to serialize a value with whatever
* serializer is configured, manually. This can be useful for serialization/unserialization of data going in
* and out of EVAL commands as phpredis can't automatically do this itself. Note that if no serializer is
* set, phpredis will change Array values to 'Array', and Objects to 'Object'.
*
* @param mixed $value The value to be serialized.
*
* @return string
* @example
* <pre>
* $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE);
* $redis->_serialize("foo"); // returns "foo"
* $redis->_serialize(Array()); // Returns "Array"
* $redis->_serialize(new stdClass()); // Returns "Object"
*
* $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP);
* $redis->_serialize("foo"); // Returns 's:3:"foo";'
* </pre>
*/
public function _serialize($value) {}
/**
* Dump a key out of a redis database, the value of which can later be passed into redis using the RESTORE command.
* The data that comes out of DUMP is a binary representation of the key as Redis stores it.
* @param string $key
*
* @return string|false|Redis A binary string representing the key's value or FALSE if the key doesn't exist or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/dump
* @example
* <pre>
* $redis->set('foo', 'bar');
* $val = $redis->dump('foo'); // $val will be the Redis encoded key value
* </pre>
*/
public function dump($key) {}
/**
* Restore a key from the result of a DUMP operation.
*
* @param string $key The name of the key you wish to create.
* @param int $ttl What Redis should set the key's TTL (in milliseconds) to once it is created.Zero means no TTL at all.
* @param string $value The serialized binary value of the string (generated by DUMP).
* @param array|null $options An array of additional options that modifies how the command operates.
* <code>
* $options = [
* 'ABSTTL' # If this is present, the `$ttl` provided by the user should
* # be an absolute timestamp, in milliseconds()
*
* 'REPLACE' # This flag instructs Redis to store the key even if a key with
* # that name already exists.
*
* 'IDLETIME' => int # Tells Redis to set the keys internal 'idletime' value to a
* # specific number (see the Redis command OBJECT for more info).
* 'FREQ' => int # Tells Redis to set the keys internal 'FREQ' value to a specific
* # number (this relates to Redis' LFU eviction algorithm).
* ];
* </code>
* @return bool|Redis True if the key was stored, false if not.
*
* @throws RedisException
*
* @link https://redis.io/commands/restore
* @example
* <pre>
* $redis->set('foo', 'bar');
* $val = $redis->dump('foo');
* $redis->restore('bar', 0, $val); // The key 'bar', will now be equal to the key 'foo'
* </pre>
*/
public function restore($key, $ttl, $value, $options = null) {}
/**
* Migrates a key to a different Redis instance.
*
* @param string $host The destination host
* @param int $port The TCP port to connect to.
* @param string|array $key The key to migrate.
* @param int $db The target DB.
* @param int $timeout The maximum amount of time given to this transfer.
* @param bool $copy Should we send the COPY flag to redis.
* @param bool $replace Should we send the REPLACE flag to redis.
* @param mixed $credentials
*
* @return bool|Redis
*
* @throws RedisException
*
* @link https://redis.io/commands/migrate
* @example
* <pre>
* $redis->migrate('backup', 6379, 'foo', 0, 3600);
* </pre>
*/
public function migrate($host, $port, $key, $dstdb, $timeout, $copy = false, $replace = false, $credentials = null) {}
/**
* Retrieve the server time from the connected Redis instance.
*
* @return false|array If successful, the time will come back as an associative array with element zero being the
* unix timestamp, and element one being microseconds.
*
* @throws RedisException
*
* @link https://redis.io/commands/time
* @example
* <pre>
* var_dump( $redis->time() );
* // array(2) {
* // [0] => string(10) "1342364352"
* // [1] => string(6) "253002"
* // }
* </pre>
*/
public function time() {}
/**
* Scan the keyspace for keys
*
* @param int|null ?$iterator The cursor returned by Redis for every subsequent call to SCAN. On
* the initial invocation of the call, it should be initialized by the
* caller to NULL. Each time SCAN is invoked, the iterator will be
* updated to a new number, until finally Redis will set the value to
* zero, indicating that the scan is complete.
*
* @param string $pattern An optional glob-style pattern for matching key names. If passed as
* NULL, it is the equivalent of sending '*' (match every key).
*
* @param int $count A hint to redis that tells it how many keys to return in a single
* call to SCAN. The larger the number, the longer Redis may block
* clients while iterating the key space.
*
* @param string|null $type An optional argument to specify which key types to scan (e.g. 'STRING', 'LIST', 'SET')
*
* @return array|false|Redis This function will return an array of keys or FALSE if there are no more keys or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/scan
* @example
* <pre>
* $redis->setOption(Redis::OPT_SCAN, Redis::SCAN_NORETRY);
*
* $it = null;
*
* do {
* $keys = $redis->scan($it, '*zorg*');
* foreach ($keys as $key) {
* echo "KEY: $key\n";
* }
* } while ($it != 0);
*
* $redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
*
* $it = null;
*
* // When Redis::SCAN_RETRY is enabled, we can use simpler logic, as we will never receive an
* // empty array of keys when the iterator is nonzero.
* while ($keys = $redis->scan($it, '*zorg*')) {
* foreach ($keys as $key) {
* echo "KEY: $key\n";
* }
* }
* </pre>
*/
public function scan(&$iterator, $pattern = null, $count = 0, $type = null) {}
/**
* Adds all the element arguments to the HyperLogLog data structure stored at the key.
*
* @param string $key
* @param array $elements
*
* @return bool|int|Redis Returns 1 if the set was altered, and zero if not. Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/pfadd
* @example $redis->pfAdd('key', array('elem1', 'elem2'))
*/
public function pfAdd($key, array $elements) {}
/**
* When called with a single key, returns the approximated cardinality computed by the HyperLogLog data
* structure stored at the specified variable, which is 0 if the variable does not exist.
*
* @param string|array $key_or_keys Either one key or an array of keys
*
* @return false|int|Redis returns Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/pfcount
* @example
* <pre>
* $redis->pfAdd('key1', array('elem1', 'elem2'));
* $redis->pfAdd('key2', array('elem3', 'elem2'));
* $redis->pfCount('key1'); // int(2)
* $redis->pfCount(array('key1', 'key2')); // int(3)
* </pre>
*/
public function pfCount($key_or_keys) {}
/**
* Merge multiple HyperLogLog values into an unique value that will approximate the cardinality
* of the union of the observed Sets of the source HyperLogLog structures.
*
* @param string $destKey
* @param array $sourceKeys
*
* @return bool|Redis returns Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/pfmerge
* @example
* <pre>
* $redis->pfAdd('key1', array('elem1', 'elem2'));
* $redis->pfAdd('key2', array('elem3', 'elem2'));
* $redis->pfMerge('key3', array('key1', 'key2'));
* $redis->pfCount('key3'); // int(3)
* </pre>
*/
public function pfMerge($destKey, array $sourceKeys) {}
/**
* Send arbitrary things to the redis server.
*
* @param string $command Required command to send to the server.
* @param mixed ...$arguments Optional variable amount of arguments to send to the server.
*
* @return mixed|Redis returns Redis if in multimode
*
* @throws RedisException
*
* @example
* <pre>
* $redis->rawCommand('SET', 'key', 'value'); // bool(true)
* $redis->rawCommand('GET", 'key'); // string(5) "value"
* </pre>
*/
public function rawCommand($command, ...$arguments) {}
/**
* Detect whether we're in ATOMIC/MULTI/PIPELINE mode.
*
* @return false|int|Redis Either Redis::ATOMIC, Redis::MULTI or Redis::PIPELINE or Redis if in multimode
*
* @throws RedisException
*
* @example $redis->getMode();
*/
public function getMode() {}
/**
* Acknowledge one or more messages on behalf of a consumer group.
*
* @param string $stream
* @param string $group
* @param array $messages
*
* @return false|int|Redis The number of messages Redis reports as acknowledged or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/xack
* @example
* <pre>
* $redis->xAck('stream', 'group1', ['1530063064286-0', '1530063064286-1']);
* </pre>
*/
public function xAck($stream, $group, $messages) {}
/**
* Append a message to a stream.
*
* @param string $key
* @param string $id The ID for the message we want to add. This can be the special value '*'
* which means Redis will generate the ID that appends the message to the
* end of the stream. It can also be a value in the form <ms>-* which will
* generate an ID that appends to the end ot entries with the same <ms> value (if any exist).
* @param array $messages
* @param int $maxlen If specified Redis will append the new message but trim any number of the
* oldest messages in the stream until the length is <= $maxlen.
* @param bool $isApproximate Used in conjunction with `$maxlen`, this flag tells Redis to trim the stream
* but in a more efficient way, meaning the trimming may not be exactly to `$maxlen` values.
* @param bool $nomkstream If passed as `TRUE`, the stream must exist for Redis to append the message.
*
* @return string|true|Redis The added message ID or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/xadd
* @example
* <pre>
* $redis->xAdd('mystream', "*", ['field' => 'value']);
* $redis->xAdd('mystream', "*", ['field' => 'value'], 10);
* $redis->xAdd('mystream', "*", ['field' => 'value'], 10, true);
* </pre>
*/
public function xAdd($key, $id, $messages, $maxLen = 0, $isApproximate = false, $nomkstream = false) {}
/**
* This method allows a consumer to take ownership of pending stream entries, by ID. Another
* command that does much the same thing but does not require passing specific IDs is `Redis::xAutoClaim`.
*
* @param string $key The stream we wish to claim messages for.
* @param string $group Our consumer group.
* @param string $consumer Our consumer.
* @param int $min_idle The minimum idle-time in milliseconds a message must have for ownership to be transferred.
* @param array $ids
* @param array $options An options array that modifies how the command operates.
*
* <code>
* # Following is an options array describing every option you can pass. Note that
* # 'IDLE', and 'TIME' are mutually exclusive.
* $options = [
* 'IDLE' => 3 # Set the idle time of the message to a 3. By default
* # the idle time is set to zero.
* 'TIME' => 1000*time() # Same as IDLE except it takes a unix timestamp in
* # milliseconds.
* 'RETRYCOUNT' => 0 # Set the retry counter to zero. By default XCLAIM
* # doesn't modify the counter.
* 'FORCE' # Creates the pending message entry even if IDs are
* # not already
* # in the PEL with another client.
* 'JUSTID' # Return only an array of IDs rather than the messages
* # themselves.
* ];
* </code>
*
* @return false|array|Redis Either an array of message IDs along with corresponding data, or just an array of IDs or Redis if in multimode
* (if the 'JUSTID' option was passed).
*
* @throws RedisException
*
* @link https://redis.io/commands/xclaim
* @example
* <pre>
* $ids = ['1530113681011-0', '1530113681011-1', '1530113681011-2'];
*
* // Without any options
* $redis->xClaim('mystream', 'group1', 'myconsumer1', 0, $ids);
*
* // With options
* $redis->xClaim(
* 'mystream', 'group1', 'myconsumer2', 0, $ids,
* [
* 'IDLE' => time() * 1000,
* 'RETRYCOUNT' => 5,
* 'FORCE',
* 'JUSTID'
* ]
* );
* </pre>
*/
public function xClaim(string $key, string $group, string $consumer, int $min_iddle, array $ids, array $options) {}
/**
* Delete one or more messages from a stream
*
* @param string $key
* @param array $ids
*
* @return false|int|Redis The number of messages removed or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/xdel
* @example
* <pre>
* $redis->xDel('mystream', ['1530115304877-0', '1530115305731-0']);
* </pre>
*/
public function xDel($key, $ids) {}
/**
* Perform various operation on consumer groups for a particular Redis STREAM. What the command does
* is primarily based on which operation is passed.
*
* @param string $operation The subcommand you intend to execute. Valid options are as follows
* 'HELP' - Redis will return information about the command
* Requires: none
* 'CREATE' - Create a consumer group.
* Requires: Key, group, consumer.
* 'SETID' - Set the ID of an existing consumer group for the stream.
* Requires: Key, group, id.
* 'CREATECONSUMER' - Create a new consumer group for the stream. You must
* also pass key, group, and the consumer name you wish to
* create.
* Requires: Key, group, consumer.
* 'DELCONSUMER' - Delete a consumer from group attached to the stream.
* Requires: Key, group, consumer.
* 'DESTROY' - Delete a consumer group from a stream.
* Requires: Key, group.
* @param string|null $key The STREAM we're operating on.
* @param string|null $group The consumer group we want to create/modify/delete.
* @param string|null $id_or_consumer The STREAM id (e.g. '$') or consumer group. See the operation section
* for information about which to send.
* @param bool $mkstream This flag may be sent in combination with the 'CREATE' operation, and
* cause Redis to also create the STREAM if it doesn't currently exist.
*
* @param int $entries_read Allows you to set Redis' 'entries-read' STREAM value. This argument is
* only relevant to the 'CREATE' and 'SETID' operations.
* Note: Requires Redis >= 7.0.0.
*
* @return mixed|Redis This command returns different types depending on the specific XGROUP command executed or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/xgroup
* @example
* <pre>
* $redis->xGroup('CREATE', 'mystream', 'mygroup', 0);
* $redis->xGroup('CREATE', 'mystream', 'mygroup', 0, true); // create stream
* $redis->xGroup('DESTROY', 'mystream', 'mygroup');
* </pre>
*/
public function xGroup($operation, $key = null, $group = null, $id_or_consumer = null, $mkstream = false, $entries_read = -2) {}
/**
* Get information about a stream or consumer groups
*
* @param string $operation The specific info operation to perform. e.g.: 'CONSUMERS', 'GROUPS', 'STREAM', 'HELP'
* @param string|null $arg1 The first argument (depends on operation)
* @param string|null $arg2 The second argument
* @param int $count The COUNT argument to `XINFO STREAM`
*
* @return mixed|Redis This command returns different types depending on which subcommand is used or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/xinfo
* @example
* <pre>
* $redis->xInfo('STREAM', 'mystream');
* </pre>
*/
public function xInfo($operation, $arg1 = null, $arg2 = null, $count = -1) {}
/**
* Get the length of a given stream.
*
* @param string $stream
*
* @return false|int|Redis The number of messages in the stream or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/xlen
* @example
* <pre>
* $redis->xLen('mystream');
* </pre>
*/
public function xLen($stream) {}
/**
* Get information about pending messages in a given stream
*
* @param string $stream The stream to inspect.
* @param string $group The user group we want to see pending messages from.
* @param string|null $start The minimum ID to consider.
* @param string|null $end The maximum ID to consider.
* @param int $count Optional maximum number of messages to return.
* @param string|null $consumer If provided, limit the returned messages to a specific consumer.
*
* @return array|string|false|Redis Information about the pending messages, in various forms depending on or Redis if in multimode
* the specific invocation of XPENDING.
*
* @throws RedisException
*
* @link https://redis.io/commands/xpending
* @example
* <pre>
* $redis->xPending('mystream', 'mygroup');
* $redis->xPending('mystream', 'mygroup', '-', '+', 1, 'consumer-1');
* </pre>
*/
public function xPending($stream, $group, $start = null, $end = null, $count = -1, $consumer = null) {}
/**
* Get a range of messages from a given stream
*
* @param string $stream The stream key name to list.
* @param string $start The minimum ID to return.
* @param string $end The maximum ID to return.
* @param int $count An optional maximum number of entries to return.
*
* @return array|bool|Redis The messages in the stream within the requested range or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/xrange
* @example
* <pre>
* // Get everything in this stream
* $redis->xRange('mystream', '-', '+');
* // Only the first two messages
* $redis->xRange('mystream', '-', '+', 2);
* </pre>
*/
public function xRange($stream, $start, $end, $count = -1) {}
/**
* Read data from one or more streams and only return IDs greater than sent in the command.
*
* @param array $streams An associative array with stream name keys and minimum id values.
* @param int $count An optional limit to how many entries are returnd *per stream*
* @param int $block An optional maximum number of milliseconds to block the caller if no data is available on any of the provided streams.
*
* @return array|bool|Redis The messages in the stream newer than the IDs passed to Redis (if any) or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/xread
* @example
* <pre>
* $redis->xRead(['stream1' => '1535222584555-0', 'stream2' => '1535222584555-0']);
* </pre>
*/
public function xRead($streams, $count = -1, $block = -1) {}
/**
* This method is similar to xRead except that it supports reading messages for a specific consumer group.
*
* @param string $group The consumer group to use.
* @param string $consumer The consumer to use.
* @param array $streams An array of stream names and message IDs
* @param int|null $count Optional maximum number of messages to return
* @param int|null $block How long to block if there are no messages available.
*
* @return array|bool|Redis The messages delivered to this consumer group (if any) or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/xreadgroup
* @example
* <pre>
* // Consume messages for 'mygroup', 'consumer1'
* $redis->xReadGroup('mygroup', 'consumer1', ['s1' => 0, 's2' => 0]);
* // Read a single message as 'consumer2' for up to a second until a message arrives.
* $redis->xReadGroup('mygroup', 'consumer2', ['s1' => 0, 's2' => 0], 1, 1000);
* </pre>
*/
public function xReadGroup($group, $consumer, $streams, $count = 1, $block = 1) {}
/**
* This is identical to xRange except the results come back in reverse order.
* Also note that Redis reverses the order of "start" and "end".
*
* @param string $stream The stream key to query.
* @param string $end The maximum message ID to include.
* @param string $start The minimum message ID to include.
* @param int $count An optional maximum number of messages to include.
*
* @return array|bool|Redis The messages in the range specified or Redis if in multimode
*
* @throws RedisException
*
* @link https://redis.io/commands/xrevrange
* @example
* <pre>
* $redis->xRevRange('mystream', '+', '-');
* $redis->xRevRange('mystream', '0-2', '0-1');
* </pre>
*/
public function xRevRange($stream, $end, $start, $count = -1) {}
/**
* Truncate a STREAM key in various ways.
*
* @param string $key The STREAM key to trim.
* @param string $threshold This can either be a maximum length, or a minimum id.
* MAXLEN - An integer describing the maximum desired length of the stream after the command.
* MINID - An ID that will become the new minimum ID in the stream, as Redis will trim all
* messages older than this ID.
* @param bool $approx Whether redis is allowed to do an approximate trimming of the stream. This is
* more efficient for Redis given how streams are stored internally.
* @param bool $minid When set to `true`, users should pass a minimum ID to the `$threshold` argument.
* @param int $limit An optional upper bound on how many entries to trim during the command.
*
* @return Redis|int|false The number of entries deleted from the stream.
*
* @see https://redis.io/commands/xtrim
*
* @example $redis->xTrim('stream', 3);
* @example $redis->xTrim('stream', '2-1', false, true);
*/
public function xtrim(string $key, string $threshold, bool $approx = false, bool $minid = false, int $limit = -1): Redis|int|false;
/**
* Adds a values to the set value stored at key.
*
* @param string $key Required key
* @param array $values Required values
*
* @return int|bool|Redis The number of elements added to the set or Redis if in multimode
* If this value is already in the set, FALSE is returned
*
* @throws RedisException
*
* @link https://redis.io/commands/sadd
* @link https://github.com/phpredis/phpredis/commit/3491b188e0022f75b938738f7542603c7aae9077
* @since phpredis 2.2.8
* @example
* <pre>
* $redis->sAddArray('k', array('v1')); // boolean
* $redis->sAddArray('k', array('v1', 'v2', 'v3')); // boolean
* </pre>
*/
public function sAddArray($key, array $values) {}
public function __destruct() {}
/**
* Compress a value with the currently configured compressor as set with Redis::setOption().
*
* @param string $value The value to be compressed
*
* @return string The compressed result
*/
public function _compress($value) {}
/**
* Uncompress the provided argument that has been compressed with the
* currently configured compressor as set with Redis::setOption().
*
* @param string $value The compressed value to uncompress.
*
* @return string The uncompressed result.
*/
public function _uncompress($value) {}
/**
* Pack the provided value with the configured serializer and compressor as set with Redis::setOption().
*
* @param mixed $value The value to pack
*
* @return string The packed result having been serialized and compressed.
*/
public function _pack($value) {}
/**
* Unpack the provided value with the configured compressor and serializer as set with Redis::setOption().
*
* @param string $value The value which has been serialized and compressed.
*
* @return mixed The uncompressed and eserialized value.
*/
public function _unpack($value) {}
/**
* Execute the Redis ACL command.
*
* @param string $subcmd Minumum of one argument for Redis and two for RedisCluster.
* @param string ...$args
*
* @return mixed
*
* @example
*
* $redis->acl('USERS'); // Get a list of users
* $redis->acl('LOG'); // See log of Redis' ACL subsystem
*/
public function acl($subcmd, ...$args) {}
/**
* POP one or more elements from one or more sorted sets, blocking up to a specified amount of time when no elements are available.
*
* @param float $timeout How long to block if there are no element available
* @param array $keys The sorted sets to pop from
* @param string $from The string 'MIN' or 'MAX' (case insensitive) telling Redis whether you wish to pop the lowest or highest scoring members from the set(s).
* @param int $count Pop up to how many elements.
*
* @return array|null|false|Redis This function will return an array of popped elements, or false
* depending on whether any elements could be popped within the specified timeout.
*
* NOTE: If Redis::OPT_NULL_MULTIBULK_AS_NULL is set to true via Redis::setOption(), this method will instead return NULL when Redis doesn't pop any elements.
* @since phpredis 6.0
*/
public function bzmpop($timeout, $keys, $from, $count = 1) {}
/**
* POP one or more of the highest or lowest scoring elements from one or more sorted sets.
*
* @link https://redis.io/commands/zmpop
*
* @param array $keys One or more sorted sets
* @param string $from The string 'MIN' or 'MAX' (case insensitive) telling Redis whether you want to pop the lowest or highest scoring elements.
* @param int $count Pop up to how many elements at once.
*
* @return array|null|false|Redis An array of popped elements or false if none could be popped.
* @since phpredis 6.0
*/
public function zmpop($keys, $from, $count = 1) {}
/**
* Pop one or more elements from one or more Redis LISTs, blocking up to a specified timeout when no elements are available.
*
* @link https://redis.io/commands/blmpop
*
* @param float $timeout The number of seconds Redis will block when no elements are available.
* @param array $keys One or more Redis LISTs to pop from.
* @param string $from The string 'LEFT' or 'RIGHT' (case insensitive), telling Redis whether to pop elements from the beginning or end of the LISTs.
* @param int $count Pop up to how many elements at once.
*
* @return array|null|false|Redis One or more elements popped from the list(s) or false if all LISTs were empty.
* @since phpredis 6.0
*/
public function blmpop($timeout, $keys, $from, $count = 1) {}
/**
* Pop one or more elements off of one or more Redis LISTs.
*
* @link https://redis.io/commands/lmpop
*
* @param array $keys An array with one or more Redis LIST key names.
* @param string $from The string 'LEFT' or 'RIGHT' (case insensitive), telling Redis whether to pop elements from the beginning or end of the LISTs.
* @param int $count The maximum number of elements to pop at once.
*
* @return array|null|false|Redis One or more elements popped from the LIST(s) or false if all the LISTs were empty.
*
* @since phpredis 6.0
*/
public function lmpop($keys, $from, $count = 1) {}
/**
* @param string|null $opt
* @param mixed ...$args
*
* @return mixed
*/
public function command($opt = null, ...$args) {}
/**
* Make a copy of a key.
*
* $redis = new Redis(['host' => 'localhost']);
*
* @param string $src The key to copy
* @param string $dst The name of the new key created from the source key.
* @param array|null $options An array with modifiers on how COPY should operate.
* 'REPLACE' => true|false # Whether to replace an existing key.
* 'DB' => int # Copy key to specific db.
*
* @return bool|Redis True if the copy was completed and false if not.
*
* @link https://redis.io/commands/copy
* @since phpredis 6.0
*
* @example
* $redis->pipeline()
* ->select(1)
* ->del('newkey')
* ->select(0)
* ->del('newkey')
* ->mset(['source1' => 'value1', 'exists' => 'old_value'])
* ->exec();
*
* var_dump($redis->copy('source1', 'newkey'));
* var_dump($redis->copy('source1', 'newkey', ['db' => 1]));
* var_dump($redis->copy('source1', 'exists'));
* var_dump($redis->copy('source1', 'exists', ['REPLACE' => true]));
*/
public function copy($src, $dst, $options = null) {}
/**
* @param string $key
*
* @return string|Redis
*/
public function debug($key) {}
/**
* This is simply the read-only variant of eval, meaning the underlying script may not modify data in redis.
*
* @param string $script_sha
* @param mixed[] $args
* @param int $num_keys
*
* @return mixed
*
* @see eval()
* @since phpredis 6.0
*/
public function eval_ro($script_sha, $args = [], $num_keys = 0) {}
/**
* This is simply the read-only variant of evalsha, meaning the underlying script may not modify data in redis.
*
* @param string $sha1
* @param mixed[] $args
* @param int $num_keys
*
* @return mixed
* @see evalsha()
* @since phpredis 6.0
*/
public function evalsha_ro($sha1, $args = [], $num_keys = 0) {}
/**
* @param array|null $to
* @param bool $abort
* @param int $timeout
*
* @return bool|Redis
* @since phpredis 6.0
*/
public function failover($to = null, $abort = false, $timeout = 0) {}
/**
* Get the expiration of a given key as a unix timestamp
*
* @param string $key The key to check.
*
* @return int|false|Redis The timestamp when the key expires, or -1 if the key has no expiry and -2 if the key doesn't exist.
*
* @link https://redis.io/commands/expiretime
* @since phpredis 6.0
*
* @example
* $redis->setEx('mykey', 60, 'myval');
* $redis->expiretime('mykey');
*/
public function expiretime($key) {}
/**
* Get the expriation timestamp of a given Redis key but in milliseconds.
*
* @param string $key The key to check
*
* @link https://redis.io/commands/pexpiretime
* @see expiretime()
* @since phpredis 6.0
*
* @return int|false|Redis The expiration timestamp of this key (in milliseconds) or -1 if the key has no expiration, and -2 if it does not exist.
*/
public function pexpiretime($key) {}
/**
* Invoke a function.
*
* @param string $fn The name of the function
* @param array $keys Optional list of keys
* @param array $args Optional list of args
*
* @return mixed Function may return arbitrary data so this method can return strings, arrays, nested arrays, etc.
*
* @link https://redis.io/commands/fcall
* @since phpredis 6.0
*/
public function fcall($fn, $keys = [], $args = []) {}
/**
* This is a read-only variant of the FCALL command that cannot execute commands that modify data.
*
* @param string $fn The name of the function
* @param array $keys Optional list of keys
* @param array $args Optional list of args
*
* @return mixed Function may return arbitrary data so this method can return strings, arrays, nested arrays, etc.
*
* @link https://redis.io/commands/fcall_ro
* @since phpredis 6.0
*/
public function fcall_ro($fn, $keys = [], $args = []) {}
/**
* Functions is an API for managing code to be executed on the server.
*
* @param string $operation The subcommand you intend to execute. Valid options are as follows
* 'LOAD' - Create a new library with the given library name and code.
* 'DELETE' - Delete the given library.
* 'LIST' - Return general information on all the libraries
* 'STATS' - Return information about the current function running
* 'KILL' - Kill the current running function
* 'FLUSH' - Delete all the libraries
* 'DUMP' - Return a serialized payload representing the current libraries
* 'RESTORE' - Restore the libraries represented by the given payload
* @param mixed $args Additional arguments
*
* @return Redis|bool|string|array Depends on subcommand.
*
* @link https://redis.io/commands/function
* @since phpredis 6.0
*/
public function function($operation, ...$args) {}
/**
* A readonly variant of `GEORADIUS` that may be executed on replicas.
*
* @param string $key
* @param float $lng
* @param float $lat
* @param float $radius
* @param string $unit
* @param mixed[] $options
*
* @return mixed
* @see georadius()
*/
public function georadius_ro($key, $lng, $lat, $radius, $unit, $options = []) {}
/**
* This is the read-only variant of `GEORADIUSBYMEMBER` that can be run on replicas.
*
* @param string $key
* @param string $member
* @param float $radius
* @param string $unit
* @param mixed[] $options
*
* @return mixed
*
* @see georadiusbymember()
*/
public function georadiusbymember_ro($key, $member, $radius, $unit, $options = []) {}
/**
* Get the value of a key and optionally set it's expiration.
*
* @param string $key The key to query
* @param array $options Options to modify how the command works.
* 'EX' => <seconds> # Expire in N seconds
* 'PX' => <milliseconds> # Expire in N milliseconds
* 'EXAT' => <timestamp> # Expire at a unix timestamp (in seconds)
* 'PXAT' => <mstimestamp> # Expire at a unix timestamp (in milliseconds);
* 'PERSIST' # Remove any configured expiration on the key.
*
* @return string|bool|Redis The key's value or false if it didn't exist.
*
* @see https://redis.io/comands/getex
* @since phpredis 6.0
*
* @example $redis->getEx('mykey', ['EX' => 60]);
*/
public function getEx($key, $options = []) {}
/**
* Get a key from Redis and delete it in an atomic operation.
*
* @param string $key The key to get/delete.
*
* @return Redis|string|bool The value of the key or false if it didn't exist.
*
* @see https://redis.io/commands/getdel
* @since phpredis 6.0
*
* @example $redis->getDel('token:123');
*/
public function getDel($key) {}
/**
* Get the longest common subsequence between two string keys.
*
* @param string $key1 The first key to check
* @param string $key2 The second key to check
* @param array|null $options An optional array of modifiers for the comand.
* 'MINMATCHLEN' => int # Exclude matching substrings that are less than this value
* 'WITHMATCHLEN' => bool # Whether each match should also include its length.
* 'LEN' # Return the length of the longest subsequence
* 'IDX' # Each returned match will include the indexes where the
* # match occurs in each string.
* NOTE: 'LEN' cannot be used with 'IDX'.
*
* @return Redis|string|array|int|false Various reply types depending on options.
*
* @link https://redis.io/commands/lcs
* @since phpredis 6.0
*
* @example
* $redis->set('seq1', 'gtaggcccgcacggtctttaatgtatccctgtttaccatgccatacctgagcgcatacgc');
* $redis->set('seq2', 'aactcggcgcgagtaccaggccaaggtcgttccagagcaaagactcgtgccccgctgagc');
* echo $redis->lcs('seq1', 'seq2') . "\n";
*/
public function lcs($key1, $key2, $options = null) {}
/**
* Get the number of bytes sent and received on the socket.
*
* @return array An array in the form [$sent_bytes, $received_bytes]
* @since phpredis 6.0
*/
public function getTransferredBytes() {}
/**
* Reset the number of bytes sent and received on the socket.
* @since phpredis 6.0
*
* @return void
*/
public function clearTransferredBytes() {}
/**
* Get one or more random field from a hash.
*
* @param string $key The hash to query.
* @param array|null $options An array of options to modify how the command behaves.
* 'COUNT' => int # An optional number of fields to return.
* 'WITHVALUES' => bool # Also return the field values.
*
* @return Redis|array|string One or more random fields (and possibly values).
*
* @see https://redis.io/commands/hrandfield
* @since phpredis 6.0
*
* @example
* $redis->hRandField('settings');
* $redis->hRandField('settings', ['count' => 2, 'withvalues' => true]);
*/
public function hRandField($key, $options = null) {}
/**
* Move an element from one list into another.
*
* @param string $src The source list.
* @param string $dst The destination list
* @param string $wherefrom Where in the source list to retrieve the element. This can be either
* - `Redis::LEFT`, or `Redis::RIGHT`.
* @param string $whereto Where in the destination list to put the element. This can be either
* - `Redis::LEFT`, or `Redis::RIGHT`.
*
* @return Redis|string|false The element removed from the source list.
* @since phpredis 6.0
*
* @example
* $redis->rPush('numbers', 'one', 'two', 'three');
* $redis->lMove('numbers', 'odds', Redis::LEFT, Redis::LEFT);
*/
public function lMove($src, $dst, $wherefrom, $whereto) {}
/**
* Move an element from one list to another, blocking up to a timeout until an element is available.
*
* @param string $src The source list
* @param string $dst The destination list
* @param string $wherefrom Where in the source list to extract the element. - `Redis::LEFT`, or `Redis::RIGHT`.
* @param string $whereto Where in the destination list to put the element.- `Redis::LEFT`, or `Redis::RIGHT`.
* @param float $timeout How long to block for an element.
*
* @return Redis|string|false;
* @since phpredis 6.0
*
* @example
* $redis->lPush('numbers', 'one');
* $redis->blmove('numbers', 'odds', Redis::LEFT, Redis::LEFT 1.0);
* // This call will block, if no additional elements are in 'numbers'
* $redis->blmove('numbers', 'odds', Redis::LEFT, Redis::LEFT, 1.0);
*/
public function blmove($src, $dst, $wherefrom, $whereto, $timeout) {}
/**
* Retrieve the index of an element in a list.
*
* @param string $key The list to query.
* @param mixed $value The value to search for.
* @param array|null $options Options to configure how the command operates
* # How many matches to return. By default a single match is returned.
* # If count is set to zero, it means unlimited.
* 'COUNT' => <num-matches>
*
* # Specify which match you want returned. `RANK` 1 means "the first match"
* # 2 means the second, and so on. If passed as a negative number the
* # RANK is computed right to left, so a `RANK` of -1 means "the last match".
* 'RANK' => <rank>
*
* # This argument allows you to limit how many elements Redis will search before
* # returning. This is useful to prevent Redis searching very long lists while
* # blocking the client.
* 'MAXLEN => <max-len>
*
* @return Redis|null|bool|int|array Returns one or more of the matching indexes, or null/false if none were found.
* @since phpredis 6.0
*/
public function lPos($key, $value, $options = null) {}
/**
* Reset the state of the connection.
*
* @return Redis|bool Should always return true unless there is an error.
* @since phpredis 6.0
*/
public function reset() {}
/**
* Compute the intersection of one or more sets and return the cardinality of the result.
*
* @param array $keys One or more set key names.
* @param int $limit A maximum cardinality to return. This is useful to put an upper bound on the amount of work Redis will do.
*
* @return Redis|int|false
*
* @link https://redis.io/commands/sintercard
* @since phpredis 6.0
*
* @example
* $redis->sAdd('set1', 'apple', 'pear', 'banana', 'carrot');
* $redis->sAdd('set2', 'apple', 'banana');
* $redis->sAdd('set3', 'pear', 'banana');
*
* $redis->sInterCard(['set1', 'set2', 'set3']);
*/
public function sInterCard($keys, $limit = -1) {}
/**
* Used to turn a Redis instance into a replica of another, or to remove
* replica status promoting the instance to a primary.
*
* @link https://redis.io/commands/replicaof
* @link https://redis.io/commands/slaveof
* @see slaveof()
* @since phpredis 6.0
*
* @param string|null $host The host of the primary to start replicating.
* @param int $port The port of the primary to start replicating.
*
* @return Redis|bool Success if we were successfully able to start replicating a primary or
* were able to promote teh replicat to a primary.
*
* @example
* $redis = new Redis(['host' => 'localhost']);
*
* // Attempt to become a replica of a Redis instance at 127.0.0.1:9999
* $redis->replicaof('127.0.0.1', 9999);
*
* // When passed no arguments, PhpRedis will deliver the command `REPLICAOF NO ONE`
* // attempting to promote the instance to a primary.
* $redis->replicaof();
*/
public function replicaof($host = null, $port = 6379) {}
/**
* Update one or more keys last modified metadata.
*
* @link https://redis.io/commands/touch/
*
* @param array|string $key_or_array Either the first key or if passed as the only argument an array of keys.
* @param string ...$more_keys One or more keys to send to the command.
*
* @return Redis|int|false This command returns the number of keys that exist and had their last modified time reset
* @since phpredis 6.0
*/
public function touch($key_or_array, ...$more_keys) {}
/**
* This is simply a read-only variant of the sort command
*
* @param string $key
* @param mixed[]|null $options
*
* @return mixed
* @see sort()
* @since phpredis 6.0
*/
public function sort_ro($key, $options = null) {}
/**
* Subscribes the client to the specified shard channels.
*
* @param array $channels One or more channel names.
* @param callable $cb The callback PhpRedis will invoke when we receive a message from one of the subscribed channels.
*
* @return bool True on success, false on faiilure. Note that this command will block the
* client in a subscribe loop, waiting for messages to arrive.
*
* @link https://redis.io/commands/ssubscribe
* @since phpredis 6.0
*
* @example
* $redis = new Redis(['host' => 'localhost']);
*
* $redis->ssubscribe(['channel-1', 'channel-2'], function ($redis, $channel, $message) {
* echo "[$channel]: $message\n";
*
* // Unsubscribe from the message channel when we read 'quit'
* if ($message == 'quit') {
* echo "Unsubscribing from '$channel'\n";
* $redis->sunsubscribe([$channel]);
* }
* });
*
* // Once we read 'quit' from both channel-1 and channel-2 the subscribe loop will be
* // broken and this command will execute.
* echo "Subscribe loop ended\n";
*/
public function ssubscribe($channels, $cb) {}
/**
* Unsubscribes the client from the given shard channels,
* or from all of them if none is given.
*
* @param array $channels One or more channels to unsubscribe from.
*
* @return Redis|array|bool The array of unsubscribed channels.
*
* @link https://redis.io/commands/sunsubscribe
* @see ssubscribe()
* @since phpredis 6.0
*
* @example
* $redis->ssubscribe(['channel-1', 'channel-2'], function ($redis, $channel, $message) {
* if ($message == 'quit') {
* echo "$channel => 'quit' detected, unsubscribing!\n";
* $redis->sunsubscribe([$channel]);
* } else {
* echo "$channel => $message\n";
* }
* });
*
* echo "We've unsubscribed from both channels, exiting\n";
*/
public function sunsubscribe($channels) {}
/**
* This command allows a consumer to claim pending messages that have been idle for a specified period of time.
* Its purpose is to provide a mechanism for picking up messages that may have had a failed consumer.
*
* @link https://redis.io/commands/xautoclaim
* @link https://redis.io/commands/xclaim
* @link https://redis.io/docs/data-types/streams-tutorial/
* @since phpredis 6.0
*
* @param string $key The stream to check.
* @param string $group The consumer group to query.
* @param string $consumer Which consumer to check.
* @param int $min_idle The minimum time in milliseconds for the message to have been pending.
* @param string $start The minimum message id to check.
* @param int $count An optional limit on how many messages are returned.
* @param bool $justid If the client only wants message IDs and not all of their data.
*
* @return Redis|array|bool An array of pending IDs or false if there are none, or on failure.
*
* @example
* $redis->xGroup('CREATE', 'ships', 'combatants', '0-0', true);
*
* $redis->xAdd('ships', '1424-74205', ['name' => 'Defiant']);
*
* // Consume the ['name' => 'Defiant'] message
* $msgs = $redis->xReadGroup('combatants', "Jem'Hadar", ['ships' => '>'], 1);
*
* // The "Jem'Hadar" consumer has the message presently
* $pending = $redis->xPending('ships', 'combatants');
* var_dump($pending);
*
* // Asssume control of the pending message with a different consumer.
* $res = $redis->xAutoClaim('ships', 'combatants', 'Sisko', 0, '0-0');
*
* // Now the 'Sisko' consumer owns the message
* $pending = $redis->xPending('ships', 'combatants');
* var_dump($pending);
*/
public function xAutoClaim($key, $group, $consumer, $min_idle, $start, $count = -1, $justid = false) {}
/**
* Count the number of elements in a sorted set whos members fall within the provided
* lexographical range.
*
* @param string $key The sorted set to check.
* @param string $min The minimum matching lexographical string
* @param string $max The maximum matching lexographical string
*
* @return Redis|int|false The number of members that fall within the range or false on failure.
*
* @link https://redis.io/commands/zlexcount
*
* @example
* $redis->zAdd('captains', 0, 'Janeway', 0, 'Kirk', 0, 'Picard', 0, 'Sisko', 0, 'Archer');
* $redis->zLexCount('captains', '[A', '[S');
*/
public function zLexCount($key, $min, $max) {}
/**
* This command is similar to ZRANGE except that instead of returning the values directly
* it will store them in a destination key provided by the user
*
* @param string $dstkey The key to store the resulting element(s)
* @param string $srckey The source key with element(s) to retrieve
* @param string $start The starting index to store
* @param string $end The ending index to store
* @param array|bool|null $options Our options array that controls how the command will function.
*
* @return Redis|int|false The number of elements stored in $dstkey or false on failure.
*
* @see https://redis.io/commands/zrange/
* @see Redis::zRange for a full description of the possible options.
* @since phpredis 6.0
*/
public function zRangeStore($dstkey, $srckey, $start, $end, $options = null) {}
/**
* Store the difference of one or more sorted sets in a destination sorted set.
*
* @param string $dst The destination set name.
* @param array $keys One or more source key names
*
* @return Redis|int|false The number of elements stored in the destination set or false on failure.
*
* @see zDiff()
* @link https://redis.io/commands/zdiff
* @since phpredis 6.0
*/
public function zDiffStore($dst, $keys) {}
/**
* Similar to ZINTER but instead of returning the intersected values, this command returns the
* cardinality of the intersected set.
*
* @link https://redis.io/commands/zintercard
* @link https://redis.io/commands/zinter
* @see zInter()
*
* @param array $keys One ore more sorted set key names.
* @param int $limit An optional upper bound on the returned cardinality. If set to a value
* greater than zero, Redis will stop processing the intersection once the
* resulting cardinality reaches this limit.
*
* @return Redis|int|false The cardinality of the intersection or false on failure.
* @since phpredis 6.0
*
* @example
* $redis->zAdd('zs1', 1, 'one', 2, 'two', 3, 'three', 4, 'four');
* $redis->zAdd('zs2', 2, 'two', 4, 'four');
*
* $redis->zInterCard(['zs1', 'zs2']);
*/
public function zInterCard($keys, $limit = -1) {}
}
class RedisException extends Exception {}
Reference in New Issue View Git Blame Copy Permalink