Write binary-safe string in the format: "$<count>\r\n<payload>\r\n". */

Get entry pointed to by 'p' and store in either '*sstr' or 'sval' depending * on the encoding of the entry. '*sstr' is always set to NULL to be able

Free an hisds string. No operation is performed if 's' is NULL. */

This is like rdbLoadLenByRef() but directly returns the value read * from the RDB stream, signaling an error by returning RDB_LENERR * (since it is

Add a Redis Object as a bulk reply */

If 'p' points to an element of the listpack, calling lpNext() will return * the pointer to the next element (the one on the right), or NULL if 'p' *

Kind destruction. */

Return the number of elements inside the radix tree. */

Schedule a client to free it at a safe time in the serverCron() function. * This function is useful when we need to terminate a client but we are in

Populate 'entry' with the element at the specified zero-based index * where 0 is the head, 1 is the element next to head * and so on. Negative integ

Convert a string into a long long. Returns 1 if the string could be parsed * into a (non-overflowing) long long, 0 otherwise. The value will be set t

Generate new string concatenating integer i against string 'prefix' */

Rewrite the specified configuration option with the new "line". * It progressively uses lines of the file that were already used for the same * conf

Remove an element, returning DICT_OK on success or DICT_ERR if the * element was not found. */

Append the specified sds 't' to the existing sds 's'. * * After the call, the modified sds string is no longer valid and all the * references must

This low level function just adds whatever protocol you send it to the * client buffer, trying the static buffer initially, and using the string * o

Saves an encoded length. The first two bits in the first byte are used to * hold the encoding type. See the RDB_* definitions for more information *

* Ensure that we don't hold any locks upon entry to or exit from allocator * code (in a "broad" sense that doesn't count a reentrant allocation as an

Like lookupKeyReadWithFlags(), but does not use any flag, which is the * common case. */

Create an sds string from a long long value. It is much faster than: * * sdscatprintf(sdsempty(),"%lld\n", value); */

Return the UNIX time in microseconds */

* Ensure that we don't hold any locks upon entry to or exit from allocator * code (in a "broad" sense that doesn't count a reentrant allocation as an

Gets the text streamed to this object so far as an std::string. Each '\0' character in the buffer is replaced with "\\0".

This is a wrapper whose behavior depends on the Redis lazy free * configuration. Deletes the key synchronously or asynchronously. */

This is called by the Redis internals every time we want to fire an * event that can be interceppted by some module. The pointer 'data' is useful *

Format a command according to the Redis protocol. This function * takes a format similar to printf: * * %s represents a C null terminated string yo

Turn the string into a smaller (or equal) string containing only the * substring specified by the 'start' and 'end' indexes. * * start and end can

Return true if the named test was selected using the -t command line * switch, or if all the tests are selected (no -t passed by user). */

Compare two sds strings s1 and s2 with memcmp(). * * Return value: * * positive if s1 > s2. * negative if s1 < s2. * 0 if s1 and s2

Allocate memory and zero it or panic */