You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1246 lines
41 KiB
Markdown
1246 lines
41 KiB
Markdown
# Generated API for Redis Modules and Redis Module Utils
|
|
|
|
## module.c
|
|
* [RedisModule_FreeCallReply](#redismodule_freecallreply)
|
|
|
|
* [RedisModule_CloseKey](#redismodule_closekey)
|
|
|
|
* [RedisModule_ZsetRangeStop](#redismodule_zsetrangestop)
|
|
|
|
* [RedisModule_GetApi](#redismodule_getapi)
|
|
|
|
* [RedisModule_IsKeysPositionRequest](#redismodule_iskeyspositionrequest)
|
|
|
|
* [RedisModule_KeyAtPos](#redismodule_keyatpos)
|
|
|
|
* [RedisModule_CreateCommand](#redismodule_createcommand)
|
|
|
|
* [RedisModule_SetModuleAttribs](#redismodule_setmoduleattribs)
|
|
|
|
* [RedisModule_AutoMemory](#redismodule_automemory)
|
|
|
|
* [RedisModule_CreateString](#redismodule_createstring)
|
|
|
|
* [RedisModule_CreateStringFromLongLong](#redismodule_createstringfromlonglong)
|
|
|
|
* [RedisModule_FreeString](#redismodule_freestring)
|
|
|
|
* [RedisModule_StringPtrLen](#redismodule_stringptrlen)
|
|
|
|
* [RedisModule_StringToLongLong](#redismodule_stringtolonglong)
|
|
|
|
* [RedisModule_StringToDouble](#redismodule_stringtodouble)
|
|
|
|
* [RedisModule_WrongArity](#redismodule_wrongarity)
|
|
|
|
* [RedisModule_ReplyWithLongLong](#redismodule_replywithlonglong)
|
|
|
|
* [RedisModule_ReplyWithError](#redismodule_replywitherror)
|
|
|
|
* [RedisModule_ReplyWithSimpleString](#redismodule_replywithsimplestring)
|
|
|
|
* [RedisModule_ReplyWithArray](#redismodule_replywitharray)
|
|
|
|
* [RedisModule_ReplySetArrayLength](#redismodule_replysetarraylength)
|
|
|
|
* [RedisModule_ReplyWithStringBuffer](#redismodule_replywithstringbuffer)
|
|
|
|
* [RedisModule_ReplyWithString](#redismodule_replywithstring)
|
|
|
|
* [RedisModule_ReplyWithNull](#redismodule_replywithnull)
|
|
|
|
* [RedisModule_ReplyWithCallReply](#redismodule_replywithcallreply)
|
|
|
|
* [RedisModule_ReplyWithDouble](#redismodule_replywithdouble)
|
|
|
|
* [RedisModule_Replicate](#redismodule_replicate)
|
|
|
|
* [RedisModule_ReplicateVerbatim](#redismodule_replicateverbatim)
|
|
|
|
* [RedisModule_GetSelectedDb](#redismodule_getselecteddb)
|
|
|
|
* [RedisModule_SelectDb](#redismodule_selectdb)
|
|
|
|
* [RedisModule_OpenKey](#redismodule_openkey)
|
|
|
|
* [RedisModule_CloseKey](#redismodule_closekey)
|
|
|
|
* [RedisModule_KeyType](#redismodule_keytype)
|
|
|
|
* [RedisModule_ValueLength](#redismodule_valuelength)
|
|
|
|
* [RedisModule_DeleteKey](#redismodule_deletekey)
|
|
|
|
* [RedisModule_GetExpire](#redismodule_getexpire)
|
|
|
|
* [RedisModule_SetExpire](#redismodule_setexpire)
|
|
|
|
* [RedisModule_StringSet](#redismodule_stringset)
|
|
|
|
* [RedisModule_StringDMA](#redismodule_stringdma)
|
|
|
|
* [RedisModule_StringTruncate](#redismodule_stringtruncate)
|
|
|
|
* [RedisModule_ListPush](#redismodule_listpush)
|
|
|
|
* [RedisModule_ListPop](#redismodule_listpop)
|
|
|
|
* [RedisModule_ZsetAddFlagsToCoreFlags](#redismodule_zsetaddflagstocoreflags)
|
|
|
|
* [RedisModule_ZsetAddFlagsFromCoreFlags](#redismodule_zsetaddflagsfromcoreflags)
|
|
|
|
* [RedisModule_ZsetAdd](#redismodule_zsetadd)
|
|
|
|
* [RedisModule_ZsetIncrby](#redismodule_zsetincrby)
|
|
|
|
* [RedisModule_ZsetRem](#redismodule_zsetrem)
|
|
|
|
* [RedisModule_ZsetScore](#redismodule_zsetscore)
|
|
|
|
* [RedisModule_ZsetRangeStop](#redismodule_zsetrangestop)
|
|
|
|
* [RedisModule_ZsetRangeEndReached](#redismodule_zsetrangeendreached)
|
|
|
|
* [RedisModule_ZsetFirstInScoreRange](#redismodule_zsetfirstinscorerange)
|
|
|
|
* [RedisModule_ZsetLastInScoreRange](#redismodule_zsetlastinscorerange)
|
|
|
|
* [RedisModule_ZsetFirstInLexRange](#redismodule_zsetfirstinlexrange)
|
|
|
|
* [RedisModule_ZsetLastInLexRange](#redismodule_zsetlastinlexrange)
|
|
|
|
* [RedisModule_ZsetRangeCurrentElement](#redismodule_zsetrangecurrentelement)
|
|
|
|
* [RedisModule_ZsetRangeNext](#redismodule_zsetrangenext)
|
|
|
|
* [RedisModule_ZsetRangePrev](#redismodule_zsetrangeprev)
|
|
|
|
* [RedisModule_HashSet](#redismodule_hashset)
|
|
|
|
* [RedisModule_HashGet](#redismodule_hashget)
|
|
|
|
* [RedisModule_FreeCallReply_Rec](#redismodule_freecallreply_rec)
|
|
|
|
* [RedisModule_FreeCallReply](#redismodule_freecallreply)
|
|
|
|
* [RedisModule_CallReplyType](#redismodule_callreplytype)
|
|
|
|
* [RedisModule_CallReplyLength](#redismodule_callreplylength)
|
|
|
|
* [RedisModule_CallReplyArrayElement](#redismodule_callreplyarrayelement)
|
|
|
|
* [RedisModule_CallReplyInteger](#redismodule_callreplyinteger)
|
|
|
|
* [RedisModule_CallReplyStringPtr](#redismodule_callreplystringptr)
|
|
|
|
* [RedisModule_CreateStringFromCallReply](#redismodule_createstringfromcallreply)
|
|
|
|
* [RedisModule_Call](#redismodule_call)
|
|
|
|
* [RedisModule_CallReplyProto](#redismodule_callreplyproto)
|
|
|
|
## util.h
|
|
* [RMUtil_ArgExists](#rmutil_argexists)
|
|
|
|
* [RMUtil_ParseArgs](#rmutil_parseargs)
|
|
|
|
* [RMUtil_ParseArgsAfter](#rmutil_parseargsafter)
|
|
|
|
* [RMUtil_GetRedisInfo](#rmutil_getredisinfo)
|
|
|
|
## strings.h
|
|
* [RMUtil_CreateFormattedString](#rmutil_createformattedstring)
|
|
|
|
* [RMUtil_StringEquals](#rmutil_stringequals)
|
|
|
|
* [RMUtil_StringToLower](#rmutil_stringtolower)
|
|
|
|
* [RMUtil_StringToUpper](#rmutil_stringtoupper)
|
|
|
|
## vector.h
|
|
* [Vector_Get](#vector_get)
|
|
|
|
* [Vector_Resize](#vector_resize)
|
|
|
|
* [Vector_Size](#vector_size)
|
|
|
|
* [Vector_Cap](#vector_cap)
|
|
|
|
* [Vector_Free](#vector_free)
|
|
### RedisModule_FreeCallReply
|
|
```
|
|
void RedisModule_FreeCallReply(RedisModuleCallReply *reply);
|
|
```
|
|
--------------------------------------------------------------------------
|
|
Prototypes
|
|
--------------------------------------------------------------------------
|
|
|
|
|
|
### RedisModule_CloseKey
|
|
```
|
|
void RedisModule_CloseKey(RedisModuleKey *key);
|
|
```
|
|
--------------------------------------------------------------------------
|
|
Prototypes
|
|
--------------------------------------------------------------------------
|
|
|
|
|
|
### RedisModule_ZsetRangeStop
|
|
```
|
|
void RedisModule_ZsetRangeStop(RedisModuleKey *key);
|
|
```
|
|
--------------------------------------------------------------------------
|
|
Prototypes
|
|
--------------------------------------------------------------------------
|
|
|
|
|
|
### RedisModule_GetApi
|
|
```
|
|
int RedisModule_GetApi(const char *funcname, void **targetPtrPtr) {
|
|
```
|
|
Lookup the requested module API and store the function pointer into the
|
|
target pointer. The function returns REDISMODULE_ERR if there is no such
|
|
named API, otherwise REDISMODULE_OK.
|
|
|
|
This function is not meant to be used by modules developer, it is only
|
|
used implicitly by including redismodule.h.
|
|
|
|
|
|
### RedisModule_IsKeysPositionRequest
|
|
```
|
|
int RedisModule_IsKeysPositionRequest(RedisModuleCtx *ctx) {
|
|
```
|
|
Return non-zero if a module command, that was declared with the
|
|
flag "getkeys-api", is called in a special way to get the keys positions
|
|
and not to get executed. Otherwise zero is returned.
|
|
|
|
|
|
### RedisModule_KeyAtPos
|
|
```
|
|
void RedisModule_KeyAtPos(RedisModuleCtx *ctx, int pos) {
|
|
```
|
|
When a module command is called in order to obtain the position of
|
|
keys, since it was flagged as "getkeys-api" during the registration,
|
|
the command implementation checks for this special call using the
|
|
RedisModule_IsKeysPositionRequest() API and uses this function in
|
|
order to report keys, like in the following example:
|
|
|
|
if (RedisModule_IsKeysPositionRequest(ctx)) {
|
|
RedisModule_KeyAtPos(ctx,1);
|
|
RedisModule_KeyAtPos(ctx,2);
|
|
}
|
|
|
|
Note: in the example below the get keys API would not be needed since
|
|
keys are at fixed positions. This interface is only used for commands
|
|
with a more complex structure.
|
|
|
|
|
|
### RedisModule_CreateCommand
|
|
```
|
|
int RedisModule_CreateCommand(RedisModuleCtx *ctx, const char *name, RedisModuleCmdFunc cmdfunc, const char *strflags, int firstkey, int lastkey, int keystep) {
|
|
```
|
|
Register a new command in the Redis server, that will be handled by
|
|
calling the function pointer 'func' using the RedisModule calling
|
|
convention. The function returns REDISMODULE_ERR if the specified command
|
|
name is already busy or a set of invalid flags were passed, otherwise
|
|
REDISMODULE_OK is returned and the new command is registered.
|
|
|
|
This function must be called during the initialization of the module
|
|
inside the RedisModule_OnLoad() function. Calling this function outside
|
|
of the initialization function is not defined.
|
|
|
|
The command function type is the following:
|
|
|
|
int MyCommand_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc);
|
|
|
|
And is supposed to always return REDISMODULE_OK.
|
|
|
|
The set of flags 'strflags' specify the behavior of the command, and should
|
|
be passed as a C string compoesd of space separated words, like for
|
|
example "write deny-oom". The set of flags are:
|
|
|
|
* **"write"**: The command may modify the data set (it may also read from it).
|
|
* **"readonly"**: The command returns data from keys but never writes.
|
|
* **"admin"**: The command is an administrative command (may change replication
|
|
or perform similar tasks).
|
|
* **"deny-oom"**: The command may use additional memory and should be denied during
|
|
out of memory conditions.
|
|
* **"deny-script"**: Don't allow this command in Lua scripts.
|
|
* **"allow-loading"**: Allow this command while the server is loading data. Only
|
|
commands not interacting with the data set should be allowed
|
|
to run in this mode. If not sure don't use this flag.
|
|
* **"pubsub"**: The command publishes things on Pub/Sub channels.
|
|
* **"random"**: The command may have different outputs even starting from the
|
|
same input arguments and key values.
|
|
* **"allow-stale"**: The command is allowed to run on slaves that don't serve stale
|
|
data. Don't use if you don't know what this means.
|
|
* **"no-monitor"**: Don't propoagate the command on monitor. Use this if the command
|
|
has sensible data among the arguments.
|
|
* **"fast"**: The command time complexity is not greater than O(log(N)) where
|
|
N is the size of the collection or anything else representing
|
|
the normal scalability issue with the command.
|
|
* **"getkeys-api"**: The command implements the interface to return the arguments
|
|
that are keys. Used when start/stop/step is not enough because
|
|
of the command syntax.
|
|
* **"no-cluster"**: The command should not register in Redis Cluster since is not
|
|
designed to work with it because, for example, is unable to
|
|
report the position of the keys, programmatically creates key
|
|
names, or any other reason.
|
|
|
|
|
|
### RedisModule_SetModuleAttribs
|
|
```
|
|
void RedisModule_SetModuleAttribs(RedisModuleCtx *ctx, const char *name, int ver, int apiver){
|
|
```
|
|
Called by RM_Init() to setup the ctx->module structure.
|
|
|
|
This is an internal function, Redis modules developers don't need
|
|
to use it.
|
|
|
|
|
|
### RedisModule_AutoMemory
|
|
```
|
|
void RedisModule_AutoMemory(RedisModuleCtx *ctx) {
|
|
```
|
|
Enable automatic memory management. See API.md for more information.
|
|
|
|
The function must be called as the first function of a command implementation
|
|
that wants to use automatic memory.
|
|
|
|
|
|
### RedisModule_CreateString
|
|
```
|
|
RedisModuleString *RedisModule_CreateString(RedisModuleCtx *ctx, const char *ptr, size_t len)
|
|
```
|
|
Create a new module string object. The returned string must be freed
|
|
with RedisModule_FreeString(), unless automatic memory is enabled.
|
|
|
|
The string is created by copying the `len` bytes starting
|
|
at `ptr`. No reference is retained to the passed buffer.
|
|
|
|
|
|
### RedisModule_CreateStringFromLongLong
|
|
```
|
|
RedisModuleString *RedisModule_CreateStringFromLongLong(RedisModuleCtx *ctx, long long ll) {
|
|
```
|
|
Like RedisModule_CreatString(), but creates a string starting from a long long
|
|
integer instead of taking a buffer and its length.
|
|
|
|
The returned string must be released with RedisModule_FreeString() or by
|
|
enabling automatic memory management.
|
|
|
|
|
|
### RedisModule_FreeString
|
|
```
|
|
void RedisModule_FreeString(RedisModuleCtx *ctx, RedisModuleString *str) {
|
|
```
|
|
Free a module string object obtained with one of the Redis modules API calls
|
|
that return new string objects.
|
|
|
|
It is possible to call this function even when automatic memory management
|
|
is enabled. In that case the string will be released ASAP and removed
|
|
from the pool of string to release at the end.
|
|
|
|
|
|
### RedisModule_StringPtrLen
|
|
```
|
|
const char *RedisModule_StringPtrLen(RedisModuleString *str, size_t *len) {
|
|
```
|
|
Given a string module object, this function returns the string pointer
|
|
and length of the string. The returned pointer and length should only
|
|
be used for read only accesses and never modified.
|
|
|
|
|
|
### RedisModule_StringToLongLong
|
|
```
|
|
int RedisModule_StringToLongLong(RedisModuleString *str, long long *ll) {
|
|
```
|
|
Convert the string into a long long integer, storing it at *ll.
|
|
Returns REDISMODULE_OK on success. If the string can't be parsed
|
|
as a valid, strict long long (no spaces before/after), REDISMODULE_ERR
|
|
is returned.
|
|
|
|
|
|
### RedisModule_StringToDouble
|
|
```
|
|
int RedisModule_StringToDouble(RedisModuleString *str, double *d) {
|
|
```
|
|
Convert the string into a double, storing it at *d.
|
|
Returns REDISMODULE_OK on success or REDISMODULE_ERR if the string is
|
|
not a valid string representation of a double value.
|
|
|
|
|
|
### RedisModule_WrongArity
|
|
```
|
|
int RedisModule_WrongArity(RedisModuleCtx *ctx) {
|
|
```
|
|
Send an error about the number of arguments given to the command,
|
|
citing the command name in the error message.
|
|
|
|
Example:
|
|
|
|
if (argc != 3) return RedisModule_WrongArity(ctx);
|
|
|
|
|
|
### RedisModule_ReplyWithLongLong
|
|
```
|
|
int RedisModule_ReplyWithLongLong(RedisModuleCtx *ctx, long long ll) {
|
|
```
|
|
Send an integer reply to the client, with the specified long long value.
|
|
The function always returns REDISMODULE_OK.
|
|
|
|
|
|
### RedisModule_ReplyWithError
|
|
```
|
|
int RedisModule_ReplyWithError(RedisModuleCtx *ctx, const char *err) {
|
|
```
|
|
Reply with the error 'err'.
|
|
|
|
Note that 'err' must contain all the error, including
|
|
the initial error code. The function only provides the initial "-", so
|
|
the usage is, for example:
|
|
|
|
RM_ReplyWithError(ctx,"ERR Wrong Type");
|
|
|
|
and not just:
|
|
|
|
RM_ReplyWithError(ctx,"Wrong Type");
|
|
|
|
The function always returns REDISMODULE_OK.
|
|
|
|
|
|
### RedisModule_ReplyWithSimpleString
|
|
```
|
|
int RedisModule_ReplyWithSimpleString(RedisModuleCtx *ctx, const char *msg) {
|
|
```
|
|
Reply with a simple string (+... \r\n in RESP protocol). This replies
|
|
are suitable only when sending a small non-binary string with small
|
|
overhead, like "OK" or similar replies.
|
|
|
|
The function always returns REDISMODULE_OK.
|
|
|
|
|
|
### RedisModule_ReplyWithArray
|
|
```
|
|
int RedisModule_ReplyWithArray(RedisModuleCtx *ctx, long len) {
|
|
```
|
|
Reply with an array type of 'len' elements. However 'len' other calls
|
|
to ReplyWith* style functions must follow in order to emit the elements
|
|
of the array.
|
|
|
|
When producing arrays with a number of element that is not known beforehand
|
|
the function can be called with the special count
|
|
REDISMODULE_POSTPONED_ARRAY_LEN, and the actual number of elements can be
|
|
later set with RedisModule_ReplySetArrayLength() (which will set the
|
|
latest "open" count if there are multiple ones).
|
|
|
|
The function always returns REDISMODULE_OK.
|
|
|
|
|
|
### RedisModule_ReplySetArrayLength
|
|
```
|
|
void RedisModule_ReplySetArrayLength(RedisModuleCtx *ctx, long len) {
|
|
```
|
|
When RedisModule_ReplyWithArray() is used with the argument
|
|
REDISMODULE_POSTPONED_ARRAY_LEN, because we don't know beforehand the number
|
|
of items we are going to output as elements of the array, this function
|
|
will take care to set the array length.
|
|
|
|
Since it is possible to have multiple array replies pending with unknown
|
|
length, this function guarantees to always set the latest array length
|
|
that was created in a postponed way.
|
|
|
|
For example in order to output an array like [1,[10,20,30]] we
|
|
could write:
|
|
|
|
RedisModule_ReplyWithArray(ctx,REDISMODULE_POSTPONED_ARRAY_LEN);
|
|
RedisModule_ReplyWithLongLong(ctx,1);
|
|
RedisModule_ReplyWithArray(ctx,REDISMODULE_POSTPONED_ARRAY_LEN);
|
|
RedisModule_ReplyWithLongLong(ctx,10);
|
|
RedisModule_ReplyWithLongLong(ctx,20);
|
|
RedisModule_ReplyWithLongLong(ctx,30);
|
|
RedisModule_ReplySetArrayLength(ctx,3); // Set len of 10,20,30 array.
|
|
RedisModule_ReplySetArrayLength(ctx,2); // Set len of top array
|
|
|
|
Note that in the above example there is no reason to postpone the array
|
|
length, since we produce a fixed number of elements, but in the practice
|
|
the code may use an interator or other ways of creating the output so
|
|
that is not easy to calculate in advance the number of elements.
|
|
|
|
|
|
### RedisModule_ReplyWithStringBuffer
|
|
```
|
|
int RedisModule_ReplyWithStringBuffer(RedisModuleCtx *ctx, const char *buf, size_t len) {
|
|
```
|
|
Reply with a bulk string, taking in input a C buffer pointer and length.
|
|
|
|
The function always returns REDISMODULE_OK.
|
|
|
|
|
|
### RedisModule_ReplyWithString
|
|
```
|
|
int RedisModule_ReplyWithString(RedisModuleCtx *ctx, RedisModuleString *str) {
|
|
```
|
|
Reply with a bulk string, taking in input a RedisModuleString object.
|
|
|
|
The function always returns REDISMODULE_OK.
|
|
|
|
|
|
### RedisModule_ReplyWithNull
|
|
```
|
|
int RedisModule_ReplyWithNull(RedisModuleCtx *ctx) {
|
|
```
|
|
Reply to the client with a NULL. In the RESP protocol a NULL is encoded
|
|
as the string "$-1\r\n".
|
|
|
|
The function always returns REDISMODULE_OK.
|
|
|
|
|
|
### RedisModule_ReplyWithCallReply
|
|
```
|
|
int RedisModule_ReplyWithCallReply(RedisModuleCtx *ctx, RedisModuleCallReply *reply) {
|
|
```
|
|
Reply exactly what a Redis command returned us with RedisModule_Call().
|
|
This function is useful when we use RedisModule_Call() in order to
|
|
execute some command, as we want to reply to the client exactly the
|
|
same reply we obtained by the command.
|
|
|
|
The function always returns REDISMODULE_OK.
|
|
|
|
|
|
### RedisModule_ReplyWithDouble
|
|
```
|
|
int RedisModule_ReplyWithDouble(RedisModuleCtx *ctx, double d) {
|
|
```
|
|
Send a string reply obtained converting the double 'd' into a bulk string.
|
|
This function is basically equivalent to converting a double into
|
|
a string into a C buffer, and then calling the function
|
|
RedisModule_ReplyWithStringBuffer() with the buffer and length.
|
|
|
|
The function always returns REDISMODULE_OK.
|
|
|
|
|
|
### RedisModule_Replicate
|
|
```
|
|
int RedisModule_Replicate(RedisModuleCtx *ctx, const char *cmdname, const char *fmt, ...) {
|
|
```
|
|
Replicate the specified command and arguments to slaves and AOF, as effect
|
|
of execution of the calling command implementation.
|
|
|
|
The replicated commands are always wrapped into the MULTI/EXEC that
|
|
contains all the commands replicated in a given module command
|
|
execution. However the commands replicated with RedisModule_Call()
|
|
are the first items, the ones replicated with RedisModule_Replicate()
|
|
will all follow before the EXEC.
|
|
|
|
Modules should try to use one interface or the other.
|
|
|
|
This command follows exactly the same interface of RedisModule_Call(),
|
|
so a set of format specifiers must be passed, followed by arguments
|
|
matching the provided format specifiers.
|
|
|
|
Please refer to RedisModule_Call() for more information.
|
|
|
|
The command returns REDISMODULE_ERR if the format specifiers are invalid
|
|
or the command name does not belong to a known command.
|
|
|
|
|
|
### RedisModule_ReplicateVerbatim
|
|
```
|
|
int RedisModule_ReplicateVerbatim(RedisModuleCtx *ctx) {
|
|
```
|
|
This function will replicate the command exactly as it was invoked
|
|
by the client. Note that this function will not wrap the command into
|
|
a MULTI/EXEC stanza, so it should not be mixed with other replication
|
|
commands.
|
|
|
|
Basically this form of replication is useful when you want to propagate
|
|
the command to the slaves and AOF file exactly as it was called, since
|
|
the command can just be re-executed to deterministically re-create the
|
|
new state starting from the old one.
|
|
|
|
The function always returns REDISMODULE_OK.
|
|
|
|
|
|
### RedisModule_GetSelectedDb
|
|
```
|
|
int RedisModule_GetSelectedDb(RedisModuleCtx *ctx) {
|
|
```
|
|
Return the currently selected DB.
|
|
|
|
|
|
### RedisModule_SelectDb
|
|
```
|
|
int RedisModule_SelectDb(RedisModuleCtx *ctx, int newid) {
|
|
```
|
|
Change the currently selected DB. Returns an error if the id
|
|
is out of range.
|
|
|
|
Note that the client will retain the currently selected DB even after
|
|
the Redis command implemented by the module calling this function
|
|
returns.
|
|
|
|
If the module command wishes to change something in a different DB and
|
|
returns back to the original one, it should call RedisModule_GetSelectedDb()
|
|
before in order to restore the old DB number before returning.
|
|
|
|
|
|
### RedisModule_OpenKey
|
|
```
|
|
void *RedisModule_OpenKey(RedisModuleCtx *ctx, robj *keyname, int mode) {
|
|
```
|
|
Return an handle representing a Redis key, so that it is possible
|
|
to call other APIs with the key handle as argument to perform
|
|
operations on the key.
|
|
|
|
The return value is the handle repesenting the key, that must be
|
|
closed with RM_CloseKey().
|
|
|
|
If the key does not exist and WRITE mode is requested, the handle
|
|
is still returned, since it is possible to perform operations on
|
|
a yet not existing key (that will be created, for example, after
|
|
a list push operation). If the mode is just READ instead, and the
|
|
key does not exist, NULL is returned. However it is still safe to
|
|
call RedisModule_CloseKey() and RedisModule_KeyType() on a NULL
|
|
value.
|
|
|
|
|
|
### RedisModule_CloseKey
|
|
```
|
|
void RedisModule_CloseKey(RedisModuleKey *key) {
|
|
```
|
|
Close a key handle.
|
|
|
|
|
|
### RedisModule_KeyType
|
|
```
|
|
int RedisModule_KeyType(RedisModuleKey *key) {
|
|
```
|
|
Return the type of the key. If the key pointer is NULL then
|
|
REDISMODULE_KEYTYPE_EMPTY is returned.
|
|
|
|
|
|
### RedisModule_ValueLength
|
|
```
|
|
size_t RedisModule_ValueLength(RedisModuleKey *key) {
|
|
```
|
|
Return the length of the value associated with the key.
|
|
For strings this is the length of the string. For all the other types
|
|
is the number of elements (just counting keys for hashes).
|
|
|
|
If the key pointer is NULL or the key is empty, zero is returned.
|
|
|
|
|
|
### RedisModule_DeleteKey
|
|
```
|
|
int RedisModule_DeleteKey(RedisModuleKey *key) {
|
|
```
|
|
If the key is open for writing, remove it, and setup the key to
|
|
accept new writes as an empty key (that will be created on demand).
|
|
On success REDISMODULE_OK is returned. If the key is not open for
|
|
writing REDISMODULE_ERR is returned.
|
|
|
|
|
|
### RedisModule_GetExpire
|
|
```
|
|
mstime_t RedisModule_GetExpire(RedisModuleKey *key) {
|
|
```
|
|
Return the key expire value, as milliseconds of remaining TTL.
|
|
If no TTL is associated with the key or if the key is empty,
|
|
REDISMODULE_NO_EXPIRE is returned.
|
|
|
|
|
|
### RedisModule_SetExpire
|
|
```
|
|
int RedisModule_SetExpire(RedisModuleKey *key, mstime_t expire) {
|
|
```
|
|
Set a new expire for the key. If the special expire
|
|
REDISMODULE_NO_EXPIRE is set, the expire is cancelled if there was
|
|
one (the same as the PERSIST command).
|
|
|
|
Note that the expire must be provided as a positive integer representing
|
|
the number of milliseconds of TTL the key should have.
|
|
|
|
The function returns REDISMODULE_OK on success or REDISMODULE_ERR if
|
|
the key was not open for writing or is an empty key.
|
|
|
|
|
|
### RedisModule_StringSet
|
|
```
|
|
int RedisModule_StringSet(RedisModuleKey *key, RedisModuleString *str) {
|
|
```
|
|
If the key is open for writing, set the specified string 'str' as the
|
|
value of the key, deleting the old value if any.
|
|
On success REDISMODULE_OK is returned. If the key is not open for
|
|
writing or there is an active iterator, REDISMODULE_ERR is returned.
|
|
|
|
|
|
### RedisModule_StringDMA
|
|
```
|
|
char *RedisModule_StringDMA(RedisModuleKey *key, size_t *len, int mode) {
|
|
```
|
|
Prepare the key associated string value for DMA access, and returns
|
|
a pointer and size (by reference), that the user can use to read or
|
|
modify the string in-place accessing it directly via pointer.
|
|
|
|
The 'mode' is composed by bitwise OR-ing the following flags:
|
|
|
|
REDISMODULE_READ -- Read access
|
|
REDISMODULE_WRITE -- Write access
|
|
|
|
If the DMA is not requested for writing, the pointer returned should
|
|
only be accessed in a read-only fashion.
|
|
|
|
On error (wrong type) NULL is returned.
|
|
|
|
DMA access rules:
|
|
|
|
1. No other key writing function should be called since the moment
|
|
the pointer is obtained, for all the time we want to use DMA access
|
|
to read or modify the string.
|
|
|
|
2. Each time RM_StringTruncate() is called, to continue with the DMA
|
|
access, RM_StringDMA() should be called again to re-obtain
|
|
a new pointer and length.
|
|
|
|
3. If the returned pointer is not NULL, but the length is zero, no
|
|
byte can be touched (the string is empty, or the key itself is empty)
|
|
so a RM_StringTruncate() call should be used if there is to enlarge
|
|
the string, and later call StringDMA() again to get the pointer.
|
|
|
|
|
|
### RedisModule_StringTruncate
|
|
```
|
|
int RedisModule_StringTruncate(RedisModuleKey *key, size_t newlen) {
|
|
```
|
|
If the string is open for writing and is of string type, resize it, padding
|
|
with zero bytes if the new length is greater than the old one.
|
|
|
|
After this call, RM_StringDMA() must be called again to continue
|
|
DMA access with the new pointer.
|
|
|
|
The function returns REDISMODULE_OK on success, and REDISMODULE_ERR on
|
|
error, that is, the key is not open for writing, is not a string
|
|
or resizing for more than 512 MB is requested.
|
|
|
|
If the key is empty, a string key is created with the new string value
|
|
unless the new length value requested is zero.
|
|
|
|
|
|
### RedisModule_ListPush
|
|
```
|
|
int RedisModule_ListPush(RedisModuleKey *key, int where, RedisModuleString *ele) {
|
|
```
|
|
Push an element into a list, on head or tail depending on 'where' argumnet.
|
|
If the key pointer is about an empty key opened for writing, the key
|
|
is created. On error (key opened for read-only operations or of the wrong
|
|
type) REDISMODULE_ERR is returned, otherwise REDISMODULE_OK is returned.
|
|
|
|
|
|
### RedisModule_ListPop
|
|
```
|
|
RedisModuleString *RedisModule_ListPop(RedisModuleKey *key, int where) {
|
|
```
|
|
Pop an element from the list, and returns it as a module string object
|
|
that the user should be free with RM_FreeString() or by enabling
|
|
automatic memory. 'where' specifies if the element should be popped from
|
|
head or tail. The command returns NULL if:
|
|
1) The list is empty.
|
|
2) The key was not open for writing.
|
|
3) The key is not a list.
|
|
|
|
|
|
### RedisModule_ZsetAddFlagsToCoreFlags
|
|
```
|
|
int RedisModule_ZsetAddFlagsToCoreFlags(int flags) {
|
|
```
|
|
Conversion from/to public flags of the Modules API and our private flags,
|
|
so that we have everything decoupled.
|
|
|
|
|
|
### RedisModule_ZsetAddFlagsFromCoreFlags
|
|
```
|
|
int RedisModule_ZsetAddFlagsFromCoreFlags(int flags) {
|
|
```
|
|
See previous function comment.
|
|
|
|
|
|
### RedisModule_ZsetAdd
|
|
```
|
|
int RedisModule_ZsetAdd(RedisModuleKey *key, double score, RedisModuleString *ele, int *flagsptr) {
|
|
```
|
|
Add a new element into a sorted set, with the specified 'score'.
|
|
If the element already exists, the score is updated.
|
|
|
|
A new sorted set is created at value if the key is an empty open key
|
|
setup for writing.
|
|
|
|
Additional flags can be passed to the function via a pointer, the flags
|
|
are both used to receive input and to communicate state when the function
|
|
returns. 'flagsptr' can be NULL if no special flags are used.
|
|
|
|
The input flags are:
|
|
|
|
REDISMODULE_ZADD_XX: Element must already exist. Do nothing otherwise.
|
|
REDISMODULE_ZADD_NX: Element must not exist. Do nothing otherwise.
|
|
|
|
The output flags are:
|
|
|
|
REDISMODULE_ZADD_ADDED: The new element was added to the sorted set.
|
|
REDISMODULE_ZADD_UPDATED: The score of the element was updated.
|
|
REDISMODULE_ZADD_NOP: No operation was performed because XX or NX flags.
|
|
|
|
On success the function returns REDISMODULE_OK. On the following errors
|
|
REDISMODULE_ERR is returned:
|
|
|
|
- The key was not opened for writing.
|
|
- The key is of the wrong type.
|
|
- 'score' double value is not a number (NaN).
|
|
|
|
|
|
### RedisModule_ZsetIncrby
|
|
```
|
|
int RedisModule_ZsetIncrby(RedisModuleKey *key, double score, RedisModuleString *ele, int *flagsptr, double *newscore) {
|
|
```
|
|
This function works exactly like RM_ZsetAdd(), but instead of setting
|
|
a new score, the score of the existing element is incremented, or if the
|
|
element does not already exist, it is added assuming the old score was
|
|
zero.
|
|
|
|
The input and output flags, and the return value, have the same exact
|
|
meaning, with the only difference that this function will return
|
|
REDISMODULE_ERR even when 'score' is a valid double number, but adding it
|
|
to the existing score resuts into a NaN (not a number) condition.
|
|
|
|
This function has an additional field 'newscore', if not NULL is filled
|
|
with the new score of the element after the increment, if no error
|
|
is returned.
|
|
|
|
|
|
### RedisModule_ZsetRem
|
|
```
|
|
int RedisModule_ZsetRem(RedisModuleKey *key, RedisModuleString *ele, int *deleted) {
|
|
```
|
|
Remove the specified element from the sorted set.
|
|
The function returns REDISMODULE_OK on success, and REDISMODULE_ERR
|
|
on one of the following conditions:
|
|
|
|
- The key was not opened for writing.
|
|
- The key is of the wrong type.
|
|
|
|
The return value does NOT indicate the fact the element was really
|
|
removed (since it existed) or not, just if the function was executed
|
|
with success.
|
|
|
|
In order to know if the element was removed, the additional argument
|
|
'deleted' must be passed, that populates the integer by reference
|
|
setting it to 1 or 0 depending on the outcome of the operation.
|
|
The 'deleted' argument can be NULL if the caller is not interested
|
|
to know if the element was really removed.
|
|
|
|
Empty keys will be handled correctly by doing nothing.
|
|
|
|
|
|
### RedisModule_ZsetScore
|
|
```
|
|
int RedisModule_ZsetScore(RedisModuleKey *key, RedisModuleString *ele, double *score) {
|
|
```
|
|
On success retrieve the double score associated at the sorted set element
|
|
'ele' and returns REDISMODULE_OK. Otherwise REDISMODULE_ERR is returned
|
|
to signal one of the following conditions:
|
|
|
|
- There is no such element 'ele' in the sorted set.
|
|
- The key is not a sorted set.
|
|
- The key is an open empty key.
|
|
|
|
|
|
### RedisModule_ZsetRangeStop
|
|
```
|
|
void RedisModule_ZsetRangeStop(RedisModuleKey *key) {
|
|
```
|
|
Stop a sorted set iteration.
|
|
|
|
|
|
### RedisModule_ZsetRangeEndReached
|
|
```
|
|
int RedisModule_ZsetRangeEndReached(RedisModuleKey *key) {
|
|
```
|
|
Return the "End of range" flag value to signal the end of the iteration.
|
|
|
|
|
|
### RedisModule_ZsetFirstInScoreRange
|
|
```
|
|
int RedisModule_ZsetFirstInScoreRange(RedisModuleKey *key, double min, double max, int minex, int maxex) {
|
|
```
|
|
Setup a sorted set iterator seeking the first element in the specified
|
|
range. Returns REDISMODULE_OK if the iterator was correctly initialized
|
|
otherwise REDISMODULE_ERR is returned in the following conditions:
|
|
|
|
1. The value stored at key is not a sorted set or the key is empty.
|
|
|
|
The range is specified according to the two double values 'min' and 'max'.
|
|
Both can be infinite using the following two macros:
|
|
|
|
REDISMODULE_POSITIVE_INFINITE for positive infinite value
|
|
REDISMODULE_NEGATIVE_INFINITE for negative infinite value
|
|
|
|
'minex' and 'maxex' parameters, if true, respectively setup a range
|
|
where the min and max value are exclusive (not included) instead of
|
|
inclusive.
|
|
|
|
|
|
### RedisModule_ZsetLastInScoreRange
|
|
```
|
|
int RedisModule_ZsetLastInScoreRange(RedisModuleKey *key, double min, double max, int minex, int maxex) {
|
|
```
|
|
Exactly like RedisModule_ZsetFirstInScoreRange() but the last element of
|
|
the range is selected for the start of the iteration instead.
|
|
|
|
|
|
### RedisModule_ZsetFirstInLexRange
|
|
```
|
|
int RedisModule_ZsetFirstInLexRange(RedisModuleKey *key, RedisModuleString *min, RedisModuleString *max) {
|
|
```
|
|
Setup a sorted set iterator seeking the first element in the specified
|
|
lexicographical range. Returns REDISMODULE_OK if the iterator was correctly
|
|
initialized otherwise REDISMODULE_ERR is returned in the
|
|
following conditions:
|
|
|
|
1. The value stored at key is not a sorted set or the key is empty.
|
|
2. The lexicographical range 'min' and 'max' format is invalid.
|
|
|
|
'min' and 'max' should be provided as two RedisModuleString objects
|
|
in the same format as the parameters passed to the ZRANGEBYLEX command.
|
|
The function does not take ownership of the objects, so they can be released
|
|
ASAP after the iterator is setup.
|
|
|
|
|
|
### RedisModule_ZsetLastInLexRange
|
|
```
|
|
int RedisModule_ZsetLastInLexRange(RedisModuleKey *key, RedisModuleString *min, RedisModuleString *max) {
|
|
```
|
|
Exactly like RedisModule_ZsetFirstInLexRange() but the last element of
|
|
the range is selected for the start of the iteration instead.
|
|
|
|
|
|
### RedisModule_ZsetRangeCurrentElement
|
|
```
|
|
RedisModuleString *RedisModule_ZsetRangeCurrentElement(RedisModuleKey *key, double *score) {
|
|
```
|
|
Return the current sorted set element of an active sorted set iterator
|
|
or NULL if the range specified in the iterator does not include any
|
|
element.
|
|
|
|
|
|
### RedisModule_ZsetRangeNext
|
|
```
|
|
int RedisModule_ZsetRangeNext(RedisModuleKey *key) {
|
|
```
|
|
Go to the next element of the sorted set iterator. Returns 1 if there was
|
|
a next element, 0 if we are already at the latest element or the range
|
|
does not include any item at all.
|
|
|
|
|
|
### RedisModule_ZsetRangePrev
|
|
```
|
|
int RedisModule_ZsetRangePrev(RedisModuleKey *key) {
|
|
```
|
|
Go to the previous element of the sorted set iterator. Returns 1 if there was
|
|
a previous element, 0 if we are already at the first element or the range
|
|
does not include any item at all.
|
|
|
|
|
|
### RedisModule_HashSet
|
|
```
|
|
int RedisModule_HashSet(RedisModuleKey *key, int flags, ...) {
|
|
```
|
|
Set the field of the specified hash field to the specified value.
|
|
If the key is an empty key open for writing, it is created with an empty
|
|
hash value, in order to set the specified field.
|
|
|
|
The function is variadic and the user must specify pairs of field
|
|
names and values, both as RedisModuleString pointers (unless the
|
|
CFIELD option is set, see later).
|
|
|
|
Example to set the hash argv[1] to the value argv[2]:
|
|
|
|
RedisModule_HashSet(key,REDISMODULE_HASH_NONE,argv[1],argv[2],NULL);
|
|
|
|
The function can also be used in order to delete fields (if they exist)
|
|
by setting them to the specified value of REDISMODULE_HASH_DELETE:
|
|
|
|
RedisModule_HashSet(key,REDISMODULE_HASH_NONE,argv[1],
|
|
REDISMODULE_HASH_DELETE,NULL);
|
|
|
|
The behavior of the command changes with the specified flags, that can be
|
|
set to REDISMODULE_HASH_NONE if no special behavior is needed.
|
|
|
|
REDISMODULE_HASH_NX: The operation is performed only if the field was not
|
|
already existing in the hash.
|
|
REDISMODULE_HASH_XX: The operation is performed only if the field was
|
|
already existing, so that a new value could be
|
|
associated to an existing filed, but no new fields
|
|
are created.
|
|
REDISMODULE_HASH_CFIELDS: The field names passed are null terminated C
|
|
strings instead of RedisModuleString objects.
|
|
|
|
Unless NX is specified, the command overwrites the old field value with
|
|
the new one.
|
|
|
|
When using REDISMODULE_HASH_CFIELDS, field names are reported using
|
|
normal C strings, so for example to delete the field "foo" the following
|
|
code can be used:
|
|
|
|
RedisModule_HashSet(key,REDISMODULE_HASH_CFIELDS,"foo",
|
|
REDISMODULE_HASH_DELETE,NULL);
|
|
|
|
Return value:
|
|
|
|
The number of fields updated (that may be less than the number of fields
|
|
specified because of the XX or NX options).
|
|
|
|
In the following case the return value is always zero:
|
|
|
|
- The key was not open for writing.
|
|
- The key was associated with a non Hash value.
|
|
|
|
|
|
### RedisModule_HashGet
|
|
```
|
|
int RedisModule_HashGet(RedisModuleKey *key, int flags, ...) {
|
|
```
|
|
Get fields from an hash value. This function is called using a variable
|
|
number of arguments, alternating a field name (as a StringRedisModule
|
|
pointer) with a pointer to a StringRedisModule pointer, that is set to the
|
|
value of the field if the field exist, or NULL if the field did not exist.
|
|
At the end of the field/value-ptr pairs, NULL must be specified as last
|
|
argument to signal the end of the arguments in the variadic function.
|
|
|
|
This is an example usage:
|
|
|
|
RedisModuleString *first, *second;
|
|
RedisModule_HashGet(mykey,REDISMODULE_HASH_NONE,argv[1],&first,
|
|
argv[2],&second,NULL);
|
|
|
|
As with RedisModule_HashSet() the behavior of the command can be specified
|
|
passing flags different than REDISMODULE_HASH_NONE:
|
|
|
|
REDISMODULE_HASH_CFIELD: field names as null terminated C strings.
|
|
|
|
REDISMODULE_HASH_EXISTS: instead of setting the value of the field
|
|
expecting a RedisModuleString pointer to pointer, the function just
|
|
reports if the field esists or not and expects an integer pointer
|
|
as the second element of each pair.
|
|
|
|
Example of REDISMODULE_HASH_CFIELD:
|
|
|
|
RedisModuleString *username, *hashedpass;
|
|
RedisModule_HashGet(mykey,"username",&username,"hp",&hashedpass, NULL);
|
|
|
|
Example of REDISMODULE_HASH_EXISTS:
|
|
|
|
int exists;
|
|
RedisModule_HashGet(mykey,argv[1],&exists,NULL);
|
|
|
|
The function returns REDISMODULE_OK on success and REDISMODULE_ERR if
|
|
the key is not an hash value.
|
|
|
|
Memory management:
|
|
|
|
The returned RedisModuleString objects should be released with
|
|
RedisModule_FreeString(), or by enabling automatic memory management.
|
|
|
|
|
|
### RedisModule_FreeCallReply_Rec
|
|
```
|
|
void RedisModule_FreeCallReply_Rec(RedisModuleCallReply *reply, int freenested){
|
|
```
|
|
Free a Call reply and all the nested replies it contains if it's an
|
|
array.
|
|
|
|
|
|
### RedisModule_FreeCallReply
|
|
```
|
|
void RedisModule_FreeCallReply(RedisModuleCallReply *reply) {
|
|
```
|
|
Wrapper for the recursive free reply function. This is needed in order
|
|
to have the first level function to return on nested replies, but only
|
|
if called by the module API.
|
|
|
|
|
|
### RedisModule_CallReplyType
|
|
```
|
|
int RedisModule_CallReplyType(RedisModuleCallReply *reply) {
|
|
```
|
|
Return the reply type.
|
|
|
|
|
|
### RedisModule_CallReplyLength
|
|
```
|
|
size_t RedisModule_CallReplyLength(RedisModuleCallReply *reply) {
|
|
```
|
|
Return the reply type length, where applicable.
|
|
|
|
|
|
### RedisModule_CallReplyArrayElement
|
|
```
|
|
RedisModuleCallReply *RedisModule_CallReplyArrayElement(RedisModuleCallReply *reply, size_t idx) {
|
|
```
|
|
Return the 'idx'-th nested call reply element of an array reply, or NULL
|
|
if the reply type is wrong or the index is out of range.
|
|
|
|
|
|
### RedisModule_CallReplyInteger
|
|
```
|
|
long long RedisModule_CallReplyInteger(RedisModuleCallReply *reply) {
|
|
```
|
|
Return the long long of an integer reply.
|
|
|
|
|
|
### RedisModule_CallReplyStringPtr
|
|
```
|
|
const char *RedisModule_CallReplyStringPtr(RedisModuleCallReply *reply, size_t *len) {
|
|
```
|
|
Return the pointer and length of a string or error reply.
|
|
|
|
|
|
### RedisModule_CreateStringFromCallReply
|
|
```
|
|
RedisModuleString *RedisModule_CreateStringFromCallReply(RedisModuleCallReply *reply) {
|
|
```
|
|
Return a new string object from a call reply of type string, error or
|
|
integer. Otherwise (wrong reply type) return NULL.
|
|
|
|
|
|
### RedisModule_Call
|
|
```
|
|
RedisModuleCallReply *RedisModule_Call(RedisModuleCtx *ctx, const char *cmdname, const char *fmt, ...) {
|
|
```
|
|
Exported API to call any Redis command from modules.
|
|
On success a RedisModuleCallReply object is returned, otherwise
|
|
NULL is returned and errno is set to the following values:
|
|
|
|
EINVAL: command non existing, wrong arity, wrong format specifier.
|
|
EPERM: operation in Cluster instance with key in non local slot.
|
|
|
|
|
|
### RedisModule_CallReplyProto
|
|
```
|
|
const char *RedisModule_CallReplyProto(RedisModuleCallReply *reply, size_t *len) {
|
|
```
|
|
Return a pointer, and a length, to the protocol returned by the command
|
|
that returned the reply object.
|
|
|
|
|
|
### RMUtil_ArgExists
|
|
```
|
|
int RMUtil_ArgExists(const char *arg, RedisModuleString **argv, int argc, int offset);
|
|
```
|
|
Return the offset of an arg if it exists in the arg list, or 0 if it's not there
|
|
|
|
|
|
### RMUtil_ParseArgs
|
|
```
|
|
int RMUtil_ParseArgs(RedisModuleString **argv, int argc, int offset, const char *fmt, ...);
|
|
```
|
|
Automatically conver the arg list to corresponding variable pointers according to a given format.
|
|
You pass it the command arg list and count, the starting offset, a parsing format, and pointers to the variables.
|
|
The format is a string consisting of the following identifiers:
|
|
|
|
c -- pointer to a Null terminated C string pointer.
|
|
s -- pointer to a RedisModuleString
|
|
l -- pointer to Long long integer.
|
|
d -- pointer to a Double
|
|
* -- do not parse this argument at all
|
|
|
|
Example: If I want to parse args[1], args[2] as a long long and double, I do:
|
|
double d;
|
|
long long l;
|
|
RMUtil_ParseArgs(argv, argc, 1, "ld", &l, &d);
|
|
|
|
|
|
### RMUtil_ParseArgsAfter
|
|
```
|
|
int RMUtil_ParseArgsAfter(const char *token, RedisModuleString **argv, int argc, const char *fmt, ...);
|
|
```
|
|
Same as RMUtil_ParseArgs, but only parses the arguments after `token`, if it was found.
|
|
This is useful for optional stuff like [LIMIT [offset] [limit]]
|
|
|
|
|
|
### RMUtil_GetRedisInfo
|
|
```
|
|
RMUtilInfo *RMUtil_GetRedisInfo(RedisModuleCtx *ctx);
|
|
```
|
|
Get redis INFO result and parse it as RMUtilInfo.
|
|
Returns NULL if something goes wrong.
|
|
The resulting object needs to be freed with RMUtilRedisInfo_Free
|
|
|
|
|
|
### RMUtil_CreateFormattedString
|
|
```
|
|
RedisModuleString *RMUtil_CreateFormattedString(RedisModuleCtx *ctx, const char *fmt, ...);
|
|
```
|
|
Create a new RedisModuleString object from a printf-style format and arguments.
|
|
Note that RedisModuleString objects CANNOT be used as formatting arguments.
|
|
|
|
|
|
### RMUtil_StringEquals
|
|
```
|
|
int RMUtil_StringEquals(RedisModuleString *s1, RedisModuleString *s2);
|
|
```
|
|
Return 1 if the two strings are equal. Case *sensitive*
|
|
|
|
|
|
### RMUtil_StringToLower
|
|
```
|
|
void RMUtil_StringToLower(RedisModuleString *s);
|
|
```
|
|
Converts a redis string to lowercase in place without reallocating anything
|
|
|
|
|
|
### RMUtil_StringToUpper
|
|
```
|
|
void RMUtil_StringToUpper(RedisModuleString *s);
|
|
```
|
|
Converts a redis string to uppercase in place without reallocating anything
|
|
|
|
|
|
### Vector_Get
|
|
```
|
|
int Vector_Get(Vector *v, int pos, void *ptr);
|
|
```
|
|
get the element at index pos. The value is copied in to ptr. If pos is outside
|
|
the vector capacity, we return 0
|
|
otherwise 1
|
|
|
|
|
|
### Vector_Resize
|
|
```
|
|
int Vector_Resize(Vector *v, int newcap);
|
|
```
|
|
resize capacity of v
|
|
|
|
|
|
### Vector_Size
|
|
```
|
|
inline int Vector_Size(Vector *v) { return v->top; }
|
|
```
|
|
return the used size of the vector, regardless of capacity
|
|
|
|
|
|
### Vector_Cap
|
|
```
|
|
inline int Vector_Cap(Vector *v) { return v->cap; }
|
|
```
|
|
return the actual capacity
|
|
|
|
|
|
### Vector_Free
|
|
```
|
|
void Vector_Free(Vector *v);
|
|
```
|
|
free the vector and the underlying data. Does not release its elements if
|
|
they are pointers
|
|
|
|
|