Increment the key with floating point precision.

*key*

*value*: (float) value that will be added to the key

*FLOAT* the new value

<pre>

$redis->incrByFloat('key1', 1.5); /* key1 didn't exist, so it will now be 1.5 */

$redis->incrByFloat('key1', 1.5); /* 3 */

$redis->incrByFloat('key1', -1.5); /* 1.5 */

$redis->incrByFloat('key1', 2.5); /* 3.5 */

</pre>

Bitwise operation on multiple keys.

*operation*: either "AND", "OR", "NOT", "XOR"

*ret_key*: return key

*key1*

*key2...*

*LONG*: The size of the string stored in the destination key.

Count bits in a string.

*key*

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

Returns an associative array from REDIS that provides information about the server. Passing

no arguments to INFO will call the standard REDIS INFO command, which returns information such

as the following:

You can pass a variety of options to INFO (per the Redis documentation), which will modify what is

returned.

$redis->info(); /* standard redis INFO command */

$redis->info("COMMANDSTATS"); /* Information on the commands that have been run (>=2.6 only)

$redis->info("CPU"); /* just CPU information from Redis INFO */

Increments the value of a hash member by the provided float value

*key*

*member*

*value*: (float) value that will be added to the member's value

*FLOAT* the new value

<pre>

$redis->delete('h');

$redis->hIncrByFloat('h','x', 1.5); /* returns 1.5: h[x] = 1.5 now */

$redis->hIncrByFLoat('h', 'x', 1.5); /* returns 3.0: h[x] = 3.0 now */

$redis->hIncrByFloat('h', 'x', -3.0); /* returns 0.0: h[x] = 0.0 now */

</pre>

Evaluate a LUA script serverside

*script* string.

*args* array, optional.

*num_keys* int, optional.

Mixed. What is returned depends on what the LUA script itself returns, which could be a scalar value (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).

<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>

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.

*script_sha* string. The sha1 encoded hash of the script you want to run.

*args* array, optional. Arguments to pass to the LUA script.

*num_keys* int, optional. The number of arguments that should go into the KEYS array, vs. the ARGV array when Redis spins the script

Mixed. See EVAL

<pre>

$script = 'return 1';

$sha = $redis->script('load', $script);

$redis->evalSha($sha); // Returns 1

</pre>

Execute the Redis SCRIPT command to perform various operations on the scripting subsystem.

<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

The last error message (if any) returned from a SCRIPT call

*none*

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

<pre>

$redis->eval('this-is-not-lua');

$err = $redis->getLastError();

// "ERR Error compiling script (new function): user_script:1: '=' expected near '-'"

</pre>

A utility method to prefix the value with the prefix setting for phpredis.

*value* string. The value you wish to prefix

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

<pre>

$redis->setOpt(Redis::OPT_PREFIX, 'my-prefix:');

$redis->_prefix('my-value'); // Will return 'my-prefix:my-value'

</pre>

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.

*value* string. The value to be unserialized

<pre>

$redis->setOpt(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>

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.

*key* string

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

<pre>

$redis->set('foo', 'bar');

$val = $redis->dump('foo'); // $val will be the Redis encoded key value

</pre>

Restore a key from the result of a DUMP operation.

*key* string. The key name

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

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

<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>

typedef enum _REDIS_REPLY_TYPE {

TYPE_LINE = '+',

TYPE_INT = ':',

TYPE_ERR = '-',

TYPE_BULK = '$',

TYPE_MULTIBULK = '*'

} REDIS_REPLY_TYPE;

#define REDIS_OPT_PREFIX 2

char *err;

int err_len;