568 lines
14 KiB
PHP
568 lines
14 KiB
PHP
<?php
|
|
|
|
namespace Illuminate\Redis\Connections;
|
|
|
|
use Closure;
|
|
use Illuminate\Contracts\Redis\Connection as ConnectionContract;
|
|
use Illuminate\Support\Arr;
|
|
use Redis;
|
|
use RedisException;
|
|
|
|
/**
|
|
* @mixin \Redis
|
|
*/
|
|
class PhpRedisConnection extends Connection implements ConnectionContract
|
|
{
|
|
use PacksPhpRedisValues;
|
|
|
|
/**
|
|
* The connection creation callback.
|
|
*
|
|
* @var callable
|
|
*/
|
|
protected $connector;
|
|
|
|
/**
|
|
* The connection configuration array.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $config;
|
|
|
|
/**
|
|
* Create a new PhpRedis connection.
|
|
*
|
|
* @param \Redis $client
|
|
* @param callable|null $connector
|
|
* @param array $config
|
|
* @return void
|
|
*/
|
|
public function __construct($client, callable $connector = null, array $config = [])
|
|
{
|
|
$this->client = $client;
|
|
$this->config = $config;
|
|
$this->connector = $connector;
|
|
}
|
|
|
|
/**
|
|
* Returns the value of the given key.
|
|
*
|
|
* @param string $key
|
|
* @return string|null
|
|
*/
|
|
public function get($key)
|
|
{
|
|
$result = $this->command('get', [$key]);
|
|
|
|
return $result !== false ? $result : null;
|
|
}
|
|
|
|
/**
|
|
* Get the values of all the given keys.
|
|
*
|
|
* @param array $keys
|
|
* @return array
|
|
*/
|
|
public function mget(array $keys)
|
|
{
|
|
return array_map(function ($value) {
|
|
return $value !== false ? $value : null;
|
|
}, $this->command('mget', [$keys]));
|
|
}
|
|
|
|
/**
|
|
* Set the string value in the argument as the value of the key.
|
|
*
|
|
* @param string $key
|
|
* @param mixed $value
|
|
* @param string|null $expireResolution
|
|
* @param int|null $expireTTL
|
|
* @param string|null $flag
|
|
* @return bool
|
|
*/
|
|
public function set($key, $value, $expireResolution = null, $expireTTL = null, $flag = null)
|
|
{
|
|
return $this->command('set', [
|
|
$key,
|
|
$value,
|
|
$expireResolution ? [$flag, $expireResolution => $expireTTL] : null,
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Set the given key if it doesn't exist.
|
|
*
|
|
* @param string $key
|
|
* @param string $value
|
|
* @return int
|
|
*/
|
|
public function setnx($key, $value)
|
|
{
|
|
return (int) $this->command('setnx', [$key, $value]);
|
|
}
|
|
|
|
/**
|
|
* Get the value of the given hash fields.
|
|
*
|
|
* @param string $key
|
|
* @param mixed $dictionary
|
|
* @return array
|
|
*/
|
|
public function hmget($key, ...$dictionary)
|
|
{
|
|
if (count($dictionary) === 1) {
|
|
$dictionary = $dictionary[0];
|
|
}
|
|
|
|
return array_values($this->command('hmget', [$key, $dictionary]));
|
|
}
|
|
|
|
/**
|
|
* Set the given hash fields to their respective values.
|
|
*
|
|
* @param string $key
|
|
* @param mixed $dictionary
|
|
* @return int
|
|
*/
|
|
public function hmset($key, ...$dictionary)
|
|
{
|
|
if (count($dictionary) === 1) {
|
|
$dictionary = $dictionary[0];
|
|
} else {
|
|
$input = collect($dictionary);
|
|
|
|
$dictionary = $input->nth(2)->combine($input->nth(2, 1))->toArray();
|
|
}
|
|
|
|
return $this->command('hmset', [$key, $dictionary]);
|
|
}
|
|
|
|
/**
|
|
* Set the given hash field if it doesn't exist.
|
|
*
|
|
* @param string $hash
|
|
* @param string $key
|
|
* @param string $value
|
|
* @return int
|
|
*/
|
|
public function hsetnx($hash, $key, $value)
|
|
{
|
|
return (int) $this->command('hsetnx', [$hash, $key, $value]);
|
|
}
|
|
|
|
/**
|
|
* Removes the first count occurrences of the value element from the list.
|
|
*
|
|
* @param string $key
|
|
* @param int $count
|
|
* @param mixed $value
|
|
* @return int|false
|
|
*/
|
|
public function lrem($key, $count, $value)
|
|
{
|
|
return $this->command('lrem', [$key, $value, $count]);
|
|
}
|
|
|
|
/**
|
|
* Removes and returns the first element of the list stored at key.
|
|
*
|
|
* @param mixed $arguments
|
|
* @return array|null
|
|
*/
|
|
public function blpop(...$arguments)
|
|
{
|
|
$result = $this->command('blpop', $arguments);
|
|
|
|
return empty($result) ? null : $result;
|
|
}
|
|
|
|
/**
|
|
* Removes and returns the last element of the list stored at key.
|
|
*
|
|
* @param mixed $arguments
|
|
* @return array|null
|
|
*/
|
|
public function brpop(...$arguments)
|
|
{
|
|
$result = $this->command('brpop', $arguments);
|
|
|
|
return empty($result) ? null : $result;
|
|
}
|
|
|
|
/**
|
|
* Removes and returns a random element from the set value at key.
|
|
*
|
|
* @param string $key
|
|
* @param int|null $count
|
|
* @return mixed|false
|
|
*/
|
|
public function spop($key, $count = 1)
|
|
{
|
|
return $this->command('spop', func_get_args());
|
|
}
|
|
|
|
/**
|
|
* Add one or more members to a sorted set or update its score if it already exists.
|
|
*
|
|
* @param string $key
|
|
* @param mixed $dictionary
|
|
* @return int
|
|
*/
|
|
public function zadd($key, ...$dictionary)
|
|
{
|
|
if (is_array(end($dictionary))) {
|
|
foreach (array_pop($dictionary) as $member => $score) {
|
|
$dictionary[] = $score;
|
|
$dictionary[] = $member;
|
|
}
|
|
}
|
|
|
|
$options = [];
|
|
|
|
foreach (array_slice($dictionary, 0, 3) as $i => $value) {
|
|
if (in_array($value, ['nx', 'xx', 'ch', 'incr', 'gt', 'lt', 'NX', 'XX', 'CH', 'INCR', 'GT', 'LT'], true)) {
|
|
$options[] = $value;
|
|
|
|
unset($dictionary[$i]);
|
|
}
|
|
}
|
|
|
|
return $this->command('zadd', array_merge([$key], [$options], array_values($dictionary)));
|
|
}
|
|
|
|
/**
|
|
* Return elements with score between $min and $max.
|
|
*
|
|
* @param string $key
|
|
* @param mixed $min
|
|
* @param mixed $max
|
|
* @param array $options
|
|
* @return array
|
|
*/
|
|
public function zrangebyscore($key, $min, $max, $options = [])
|
|
{
|
|
if (isset($options['limit']) && Arr::isAssoc($options['limit'])) {
|
|
$options['limit'] = [
|
|
$options['limit']['offset'],
|
|
$options['limit']['count'],
|
|
];
|
|
}
|
|
|
|
return $this->command('zRangeByScore', [$key, $min, $max, $options]);
|
|
}
|
|
|
|
/**
|
|
* Return elements with score between $min and $max.
|
|
*
|
|
* @param string $key
|
|
* @param mixed $min
|
|
* @param mixed $max
|
|
* @param array $options
|
|
* @return array
|
|
*/
|
|
public function zrevrangebyscore($key, $min, $max, $options = [])
|
|
{
|
|
if (isset($options['limit']) && Arr::isAssoc($options['limit'])) {
|
|
$options['limit'] = [
|
|
$options['limit']['offset'],
|
|
$options['limit']['count'],
|
|
];
|
|
}
|
|
|
|
return $this->command('zRevRangeByScore', [$key, $min, $max, $options]);
|
|
}
|
|
|
|
/**
|
|
* Find the intersection between sets and store in a new set.
|
|
*
|
|
* @param string $output
|
|
* @param array $keys
|
|
* @param array $options
|
|
* @return int
|
|
*/
|
|
public function zinterstore($output, $keys, $options = [])
|
|
{
|
|
return $this->command('zinterstore', [$output, $keys,
|
|
$options['weights'] ?? null,
|
|
$options['aggregate'] ?? 'sum',
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Find the union between sets and store in a new set.
|
|
*
|
|
* @param string $output
|
|
* @param array $keys
|
|
* @param array $options
|
|
* @return int
|
|
*/
|
|
public function zunionstore($output, $keys, $options = [])
|
|
{
|
|
return $this->command('zunionstore', [$output, $keys,
|
|
$options['weights'] ?? null,
|
|
$options['aggregate'] ?? 'sum',
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Scans all keys based on options.
|
|
*
|
|
* @param mixed $cursor
|
|
* @param array $options
|
|
* @return mixed
|
|
*/
|
|
public function scan($cursor, $options = [])
|
|
{
|
|
$result = $this->client->scan($cursor,
|
|
$options['match'] ?? '*',
|
|
$options['count'] ?? 10
|
|
);
|
|
|
|
if ($result === false) {
|
|
$result = [];
|
|
}
|
|
|
|
return $cursor === 0 && empty($result) ? false : [$cursor, $result];
|
|
}
|
|
|
|
/**
|
|
* Scans the given set for all values based on options.
|
|
*
|
|
* @param string $key
|
|
* @param mixed $cursor
|
|
* @param array $options
|
|
* @return mixed
|
|
*/
|
|
public function zscan($key, $cursor, $options = [])
|
|
{
|
|
$result = $this->client->zscan($key, $cursor,
|
|
$options['match'] ?? '*',
|
|
$options['count'] ?? 10
|
|
);
|
|
|
|
if ($result === false) {
|
|
$result = [];
|
|
}
|
|
|
|
return $cursor === 0 && empty($result) ? false : [$cursor, $result];
|
|
}
|
|
|
|
/**
|
|
* Scans the given hash for all values based on options.
|
|
*
|
|
* @param string $key
|
|
* @param mixed $cursor
|
|
* @param array $options
|
|
* @return mixed
|
|
*/
|
|
public function hscan($key, $cursor, $options = [])
|
|
{
|
|
$result = $this->client->hscan($key, $cursor,
|
|
$options['match'] ?? '*',
|
|
$options['count'] ?? 10
|
|
);
|
|
|
|
if ($result === false) {
|
|
$result = [];
|
|
}
|
|
|
|
return $cursor === 0 && empty($result) ? false : [$cursor, $result];
|
|
}
|
|
|
|
/**
|
|
* Scans the given set for all values based on options.
|
|
*
|
|
* @param string $key
|
|
* @param mixed $cursor
|
|
* @param array $options
|
|
* @return mixed
|
|
*/
|
|
public function sscan($key, $cursor, $options = [])
|
|
{
|
|
$result = $this->client->sscan($key, $cursor,
|
|
$options['match'] ?? '*',
|
|
$options['count'] ?? 10
|
|
);
|
|
|
|
if ($result === false) {
|
|
$result = [];
|
|
}
|
|
|
|
return $cursor === 0 && empty($result) ? false : [$cursor, $result];
|
|
}
|
|
|
|
/**
|
|
* Execute commands in a pipeline.
|
|
*
|
|
* @param callable|null $callback
|
|
* @return \Redis|array
|
|
*/
|
|
public function pipeline(callable $callback = null)
|
|
{
|
|
$pipeline = $this->client()->pipeline();
|
|
|
|
return is_null($callback)
|
|
? $pipeline
|
|
: tap($pipeline, $callback)->exec();
|
|
}
|
|
|
|
/**
|
|
* Execute commands in a transaction.
|
|
*
|
|
* @param callable|null $callback
|
|
* @return \Redis|array
|
|
*/
|
|
public function transaction(callable $callback = null)
|
|
{
|
|
$transaction = $this->client()->multi();
|
|
|
|
return is_null($callback)
|
|
? $transaction
|
|
: tap($transaction, $callback)->exec();
|
|
}
|
|
|
|
/**
|
|
* Evaluate a LUA script serverside, from the SHA1 hash of the script instead of the script itself.
|
|
*
|
|
* @param string $script
|
|
* @param int $numkeys
|
|
* @param mixed $arguments
|
|
* @return mixed
|
|
*/
|
|
public function evalsha($script, $numkeys, ...$arguments)
|
|
{
|
|
return $this->command('evalsha', [
|
|
$this->script('load', $script), $arguments, $numkeys,
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Evaluate a script and return its result.
|
|
*
|
|
* @param string $script
|
|
* @param int $numberOfKeys
|
|
* @param dynamic $arguments
|
|
* @return mixed
|
|
*/
|
|
public function eval($script, $numberOfKeys, ...$arguments)
|
|
{
|
|
return $this->command('eval', [$script, $arguments, $numberOfKeys]);
|
|
}
|
|
|
|
/**
|
|
* Subscribe to a set of given channels for messages.
|
|
*
|
|
* @param array|string $channels
|
|
* @param \Closure $callback
|
|
* @return void
|
|
*/
|
|
public function subscribe($channels, Closure $callback)
|
|
{
|
|
$this->client->subscribe((array) $channels, function ($redis, $channel, $message) use ($callback) {
|
|
$callback($message, $channel);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Subscribe to a set of given channels with wildcards.
|
|
*
|
|
* @param array|string $channels
|
|
* @param \Closure $callback
|
|
* @return void
|
|
*/
|
|
public function psubscribe($channels, Closure $callback)
|
|
{
|
|
$this->client->psubscribe((array) $channels, function ($redis, $pattern, $channel, $message) use ($callback) {
|
|
$callback($message, $channel);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Subscribe to a set of given channels for messages.
|
|
*
|
|
* @param array|string $channels
|
|
* @param \Closure $callback
|
|
* @param string $method
|
|
* @return void
|
|
*/
|
|
public function createSubscription($channels, Closure $callback, $method = 'subscribe')
|
|
{
|
|
//
|
|
}
|
|
|
|
/**
|
|
* Flush the selected Redis database.
|
|
*
|
|
* @return mixed
|
|
*/
|
|
public function flushdb()
|
|
{
|
|
$arguments = func_get_args();
|
|
|
|
if (strtoupper((string) ($arguments[0] ?? null)) === 'ASYNC') {
|
|
return $this->command('flushdb', [true]);
|
|
}
|
|
|
|
return $this->command('flushdb');
|
|
}
|
|
|
|
/**
|
|
* Execute a raw command.
|
|
*
|
|
* @param array $parameters
|
|
* @return mixed
|
|
*/
|
|
public function executeRaw(array $parameters)
|
|
{
|
|
return $this->command('rawCommand', $parameters);
|
|
}
|
|
|
|
/**
|
|
* Run a command against the Redis database.
|
|
*
|
|
* @param string $method
|
|
* @param array $parameters
|
|
* @return mixed
|
|
*
|
|
* @throws \RedisException
|
|
*/
|
|
public function command($method, array $parameters = [])
|
|
{
|
|
try {
|
|
return parent::command($method, $parameters);
|
|
} catch (RedisException $e) {
|
|
foreach (['went away', 'socket', 'read error on connection'] as $errorMessage) {
|
|
if (str_contains($e->getMessage(), $errorMessage)) {
|
|
$this->client = $this->connector ? call_user_func($this->connector) : $this->client;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Disconnects from the Redis instance.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function disconnect()
|
|
{
|
|
$this->client->close();
|
|
}
|
|
|
|
/**
|
|
* Pass other method calls down to the underlying client.
|
|
*
|
|
* @param string $method
|
|
* @param array $parameters
|
|
* @return mixed
|
|
*/
|
|
public function __call($method, $parameters)
|
|
{
|
|
return parent::__call(strtolower($method), $parameters);
|
|
}
|
|
}
|