本文基于Redis 6.0.9版本，前提至少 Redis 3.0或更高版本。
本篇只是作为资料参考
目录
RedisModule_IsKeysPositionRequest
RedisModule_CreateStringPrintf
RedisModule_CreateStringFromLongLong
RedisModule_CreateStringFromDouble
RedisModule_CreateStringFromLongDouble
RedisModule_CreateStringFromString
RedisModule_StringToLongDouble
RedisModule_StringAppendBuffer
RedisModule_ReplyWithSimpleString
RedisModule_ReplyWithNullArray
RedisModule_ReplyWithEmptyArray
RedisModule_ReplySetArrayLength
RedisModule_ReplyWithStringBuffer
RedisModule_ReplyWithEmptyString
RedisModule_ReplyWithVerbatimString
RedisModule_ReplyWithCallReply
RedisModule_ReplyWithLongDouble
RedisModule_AvoidReplicaTraffic
RedisModule_ZsetAddFlagsToCoreFlags
RedisModule_ZsetAddFlagsFromCoreFlags
RedisModule_ZsetRangeEndReached
RedisModule_ZsetFirstInScoreRange
RedisModule_ZsetLastInScoreRange
RedisModule_ZsetFirstInLexRange
RedisModule_ZsetLastInLexRange
RedisModule_ZsetRangeCurrentElement
RedisModule_CallReplyArrayElement
RedisModule_CallReplyStringPtr
RedisModule_CreateStringFromCallReply
RedisModule_ModuleTypeSetValue
RedisModule_ModuleTypeGetValue
RedisModule_DigestAddStringBuffer
RedisModule_GetKeyNameFromModuleKey
RedisModule_SetDisconnectCallback
RedisModule_IsBlockedReplyRequest
RedisModule_IsBlockedTimeoutRequest
RedisModule_GetBlockedClientPrivateData
RedisModule_GetBlockedClientReadyKey
RedisModule_GetBlockedClientHandle
RedisModule_BlockedClientDisconnected
RedisModule_GetThreadSafeContext
RedisModule_GetDetachedThreadSafeContext
RedisModule_FreeThreadSafeContext
RedisModule_ThreadSafeContextLock
RedisModule_ThreadSafeContextTryLock
RedisModule_ThreadSafeContextUnlock
RedisModule_SubscribeToKeyspaceEvents
RedisModule_GetNotifyKeyspaceEvents
RedisModule_NotifyKeyspaceEvent
RedisModule_RegisterClusterMessageReceiver
RedisModule_SendClusterMessage
RedisModule_GetClusterNodesList
RedisModule_FreeClusterNodesList
RedisModule_AuthenticateClientWithUser
RedisModule_AuthenticateClientWithACLUser
RedisModule_DeauthenticateAndCloseClient
RedisModule_GetClientCertificate
RedisModule_DictIteratorStartC
RedisModule_DictIteratorReseekC
RedisModule_DictIteratorReseek
RedisModule_InfoBeginDictField
RedisModule_InfoAddFieldString
RedisModule_ServerInfoGetField
RedisModule_ServerInfoGetFieldC
RedisModule_ServerInfoGetFieldSigned
RedisModule_ServerInfoGetFieldUnsigned
RedisModule_ServerInfoGetFieldDouble
RedisModule_UnregisterCommandFilter
RedisModule_CommandFilterArgsCount
RedisModule_CommandFilterArgGet
RedisModule_CommandFilterArgDelete
RedisModule_GetUsedMemoryRatio
RedisModule_SubscribeToServerEvent
RedisModuleEvent_ReplicaChange
RedisModuleEvent_MasterLinkChange
RedisModuleEvent_LoadingProgress
RedisModule_IsSubEventSupported
RedisModule_GetContextFlagsAll
RedisModule_GetKeyspaceNotificationFlagsAll
RedisModule_ModuleTypeReplaceValue
1.模块API参考
RedisModule_Alloc
void *RedisModule_Alloc(size_t bytes);使用像malloc()一样。 使用此功能分配的内存在Redis INFO内存中报告，根据最大内存设置用于键退出，通常将其作为Redis分配的内存考虑在内。 应该避免使用malloc()。
RedisModule_Calloc
void *RedisModule_Calloc(size_t nmemb, size_t size);像calloc()一样使用。 使用此功能分配的内存在Redis INFO内存中报告，根据最大内存设置用于键退出，通常将其作为Redis分配的内存考虑在内。你应该避免直接使用calloc()。
RedisModule_Realloc
void* RedisModule_Realloc(void *ptr, size_t bytes);
像 realloc() 一样使用RedisModule_Alloc()获得的内存。
RedisModule_Free
void RedisModule_Free(void *ptr);像 free() 一样使用 RedisModule_Alloc()和 RedisModule_Realloc()获得的内存。 但是，你永远不要尝试通过模块内部由malloc() 分配的 RedisModule_Free()内存释放内存。
RedisModule_Strdup
char *RedisModule_Strdup(const char *str);与strdup() 类似，但是返回分配给RedisModule_Alloc()的内存。
RedisModule_PoolAlloc
void *RedisModule_PoolAlloc(RedisModuleCtx *ctx, size_t bytes);返回分配给堆的内存，该内存将在模块回调函数返回时自动释放。 最适合寿命短的小分配，无论如何要在回调返回时将其释放。 如果至少请求字长字节，则返回的内存与体系结构字长对齐，否则，仅与下一个2的幂对齐，因此，例如，3字节的请求为4字节对齐，而2字节的请求为2字节对齐
没有重新分配样式函数，因为在需要使用池分配器时并不是一个好主意。
如果字节为0，则该函数返回NULL。
RedisModule_GetApi
int RedisModule_GetApi(const char *funcname, void **targetPtrPtr);查找请求的模块API，并将函数指针存储到目标指针中。 如果没有这样的命名API，该函数将返回REDISMODULE_ERR，否则返回REDISMODULE_OK。
此功能并不供模块开发人员使用，它仅通过包含redismodule.h隐式使用。
RedisModule_IsKeysPositionRequest
int RedisModule_IsKeysPositionRequest(RedisModuleCtx *ctx);如果使用"getkeys-api"标志声明的模块命令以一种特殊的方式被调用以获取键的位置而不执行，则返回非零值。否则返回零。
RedisModule_KeyAtPos
void RedisModule_KeyAtPos(RedisModuleCtx *ctx, int pos);当一个模块命令被调用以获得密钥的位置，因为它在注册过程中被标记为“getkeys-api” ，命令实现使用 RedisModule_IsKeysPositionRequest() API 检查这个特殊的调用，并使用这个函数来报告键，如下例所示:
if (RedisModule_IsKeysPositionRequest(ctx)) {
RedisModule_KeyAtPos(ctx,1);
RedisModule_KeyAtPos(ctx,2);
}注意: 在下面的例子中，不需要 get keys API，因为 key 位于固定的位置。此接口仅用于具有更复杂结构的命令。
RedisModule_CreateCommand
int RedisModule_CreateCommand(RedisModuleCtx *ctx, const char *name, RedisModuleCmdFunc cmdfunc, const char *strflags, int firstkey, int lastkey, int keystep);在Redis服务器中注册一个新命令，这将通过使用RedisModule调用约定调用函数指针'func'进行处理。 如果指定的命令名称已经很忙或者传递了一组无效的标志，该函数将返回REDISMODULE_ERR，否则返回REDISMODULE_OK并注册新命令。
在RedisModule_OnLoad()函数内部的模块初始化期间必须调用此函数。 未定义在初始化函数之外调用此函数。
命令函数类型如下:
int MyCommand_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc);并且应该总是返回REDISMODULE_OK。
标志“strflags”集指定命令的行为，并应作为由空格分隔的单词组成的C字符串传递，例如“write deny-oom”。 标志集为：
- "write": 该命令可以修改数据集（也可以从中读取）。
- "readonly":该命令从键返回数据，但从不写数据。
- "admin": 该命令是管理命令（可以更改复制或执行类似任务）。
- "deny-oom": 该命令可能会使用额外的内存，并且在内存不足的情况下应拒绝该命令。
- "deny-script": 在Lua脚本中不允许此命令。
- "allow-loading": 服务器正在加载数据时，请允许此命令。 仅不与数据集交互的命令应被允许在此模式下运行。 如果不确定，请不要使用此标志。
- "pubsub": 该命令在发布/订阅通道上发布内容。
- "random": 即使从相同的输入参数和键值开始，该命令也可能具有不同的输出。
- "allow-stale": 该命令允许在不提供过时数据的从节点上运行。 如果你不知道这意味着什么，请不要使用。
- "no-monitor": 不要在监视器上传播该命令。 如果命令在参数中包含有意义的数据，请使用此选项。
- "no-slowlog": 不要在慢日志中记录此命令。 如果命令在参数中包含有意义的数据，请使用此选项。
- "fast": 命令时间复杂度不大于O(log(N))，其中N是集合的大小或代表该命令正常可伸缩性问题的任何其他内容。
- "getkeys-api": 该命令实现接口以返回作为键的参数。 当由于命令语法而start/stop/step不够时使用。
- "no-cluster": 该命令不应在Redis Cluster中注册，因为该命令不适用于该命令，例如，由于无法报告键的位置，无法以编程方式创建键名称或任何其他原因，因此该命令不应在Redis Cluster中使用。
- "no-auth": 该命令可以由未经身份验证的客户端运行。 通常，此命令由用于验证客户端的命令使用。
RedisModule_SetModuleAttribs
void RedisModule_SetModuleAttribs(RedisModuleCtx *ctx, const char *name, int ver, int apiver);由RM_Init()调用以设置ctx-> module结构。
这是一个内部功能，Redis模块开发人员无需使用它。
RedisModule_IsModuleNameBusy
int RedisModule_IsModuleNameBusy(const char *name);如果模块名称繁忙，则返回非零值。 否则返回零。
RedisModule_Milliseconds
long long RedisModule_Milliseconds(void);返回当前UNIX时间（以毫秒为单位）。
RedisModule_SetModuleOptions
void RedisModule_SetModuleOptions(RedisModuleCtx *ctx, int options);设置定义功能或行为bit 标志的标志。
REDISMODULE_OPTIONS_HANDLE_IO_ERRORS: 通常，模块不需要为此烦恼，因为如果发生读取错误，则该过程将终止，但是，设置此标志将允许repl-diskless-load（如果启用）工作。 该模块应在读取后，使用读取的数据之前使用RedisModule_IsIOError，并且在出现错误的情况下，应将其向上传播，并能够释放部分填充的值及其所有分配。
RedisModule_SignalModifiedKey
int RedisModule_SignalModifiedKey(RedisModuleCtx *ctx, RedisModuleString *keyname);表示从用户角度修改了键（即使WATCH和客户端缓存无效）。
RedisModule_AutoMemory
void RedisModule_AutoMemory(RedisModuleCtx *ctx);启用自动内存管理。
该函数必须作为要使用自动内存的命令实现的第一个函数。
启用后，一旦命令返回，自动内存管理将跟踪并自动释放键，调用回复和Redis字符串对象。 在大多数情况下，这无需调用以下函数：
RedisModule_CloseKey()-
RedisModule_FreeCallReply() -
RedisModule_FreeString()
这些功能仍可在启用自动内存管理的情况下使用，以优化进行大量分配的循环。
RedisModule_CreateString
RedisModuleString *RedisModule_CreateString(RedisModuleCtx *ctx, const char *ptr, size_t len);创建一个新的模块字符串对象。 除非启用了自动内存，否则必须使用RedisModule_FreeString()释放返回的字符串。
通过复制从ptr开始的len字节来创建字符串。 没有引用保留到传递的缓冲区。
模块上下文'ctx'是可选的，如果要在上下文范围之外创建字符串，则可以为NULL。 但是，在这种情况下，自动内存管理将不可用，并且必须手动管理字符串内存。
RedisModule_CreateStringPrintf
RedisModuleString *RedisModule_CreateStringPrintf(RedisModuleCtx *ctx, const char *fmt, ...);从printf格式和参数创建一个新的模块字符串对象。 除非启用了自动内存，否则必须使用RedisModule_FreeString()释放返回的字符串。
使用sds格式化程序sdscatvprintf（）创建该字符串。
如果需要，传递的上下文'ctx'可以为NULL，有关更多信息，请参见RedisModule_CreateString()文档。
RedisModule_CreateStringFromLongLong
RedisModuleString *RedisModule_CreateStringFromLongLong(RedisModuleCtx *ctx, long long ll);与RedisModule_CreatString(),类似，但是会创建一个从长整数开始的字符串，而不是使用缓冲区及其长度。
必须使用RedisModule_FreeString() 或通过启用自动内存管理来释放返回的字符串。
如果需要，传递的上下文'ctx'可以为NULL，有关更多信息，请参见 RedisModule_CreateString() 文档。
RedisModule_CreateStringFromDouble
RedisModuleString *RedisModule_CreateStringFromDouble(RedisModuleCtx *ctx, double d);与RedisModule_CreatString()类似，但是创建一个从double开始的字符串，而不是使用缓冲区及其长度。
必须使用RedisModule_FreeString()或通过启用自动内存管理来释放返回的字符串。
RedisModule_CreateStringFromLongDouble
RedisModuleString *RedisModule_CreateStringFromLongDouble(RedisModuleCtx *ctx, long double ld, int humanfriendly);类似于RedisModule_CreatString()，但是会创建一个从长整数开始的字符串。
必须使用RedisModule_FreeString()或通过启用自动内存管理来释放返回的字符串。
如果需要，传递的上下文'ctx'可以为NULL，有关更多信息，请参见RedisModule_CreateString()文档。
RedisModule_CreateStringFromString
RedisModuleString *RedisModule_CreateStringFromString(RedisModuleCtx *ctx, const RedisModuleString *str);与RedisModule_CreatString()类似，但是从另一个RedisModuleString开始创建一个字符串。
必须使用RedisModule_FreeString()或通过启用自动内存管理来释放返回的字符串。
如果需要，传递的上下文'ctx'可以为NULL，有关更多信息，请参见RedisModule_CreateString()文档。
RedisModule_FreeString
void RedisModule_FreeString(RedisModuleCtx *ctx, RedisModuleString *str);释放通过其中一个Redis模块API调用返回的新字符串对象获得的模块字符串对象。
即使启用了自动内存管理，也可以调用此功能。 在这种情况下，字符串将尽快释放，并从字符串池中删除，最后释放。
如果该字符串是使用NULL上下文“ctx”创建的，则在释放字符串时也可以将ctx作为NULL传递（但传递上下文不会造成任何问题）。 使用上下文创建的字符串也应通过上下文释放，因此，如果你以后想从上下文中释放字符串，请确保使用NULL上下文创建它。
RedisModule_RetainString
void RedisModule_RetainString(RedisModuleCtx *ctx, RedisModuleString *str);每次对此函数的调用，都会使字符串“str”需要再次调用RedisModule_FreeString()才能真正释放该字符串。请注意，自动释放获得的字符串会启用模块，自动内存管理将计入一次RedisModule_FreeString（）调用（它会自动执行）。
通常，你希望同时满足以下条件时调用此函数：
- 你已启用自动内存管理。
- 你要创建字符串对象。
- 你创建的那些字符串对象需要在创建它们的回调函数（例如命令实现）返回之后再使用。
通常，你希望这样做是为了将创建的字符串对象存储到自己的数据结构中，例如在实现新数据类型时。
请注意，在关闭内存管理时，不需要任何RetainString()调用，因为如果不执行FreeString()调用，则创建字符串将始终导致该字符串在回调函数返回后仍然存在。
可以在NULL上下文中调用此函数。
RedisModule_HoldString
RedisModuleString* RedisModule_HoldString(RedisModuleCtx *ctx, RedisModuleString *str);可以使用此函数代替RedisModule_RetainString()。 两者之间的主要区别是此函数将始终成功，因此RedisModule_RetainString()可能会因断言而失败。 该函数返回指向RedisModuleString的指针，该指针归调用者所有。 当为上下文禁用自动内存管理时，它需要调用RedisModule_FreeString()以释放字符串。 启用自动内存管理后，你可以调用RedisModule_FreeString()或让自动化工具释放它。 此功能比RedisModule_CreateStringFromString()更有效，因为只要有可能，它就避免了复制底层的RedisModuleString。 使用此函数的缺点是可能无法在返回的RedisModuleString上使用RedisModule_StringAppendBuffer()。 可以在NULL上下文中调用此函数。
RedisModule_StringPtrLen
const char *RedisModule_StringPtrLen(const RedisModuleString *str, size_t *len);给定一个字符串模块对象，此函数返回字符串指针和字符串的长度。 返回的指针和长度应仅用于只读访问，不得修改。
RedisModule_StringToLongLong
int RedisModule_StringToLongLong(const RedisModuleString *str, long long *ll);将字符串转换为长整数，将其存储在*ll。 成功返回REDISMODULE_OK。 如果无法将字符串解析为有效的严格long long（之前/之后没有空格），则返回REDISMODULE_ERR。
RedisModule_StringToDouble
int RedisModule_StringToDouble(const RedisModuleString *str, double *d);将字符串转换为双精度形式，并将其存储在* d中。 成功返回REDISMODULE_OK，如果字符串不是双精度值的有效字符串表示形式，则返回REDISMODULE_ERR。
RedisModule_StringToLongDouble
int RedisModule_StringToLongDouble(const RedisModuleString *str, long double *ld);将字符串转换为长整数，并将其存储在* ld中。 成功返回REDISMODULE_OK，如果字符串不是双精度值的有效字符串表示形式，则返回REDISMODULE_ERR。
RedisModule_StringCompare
int RedisModule_StringCompare(RedisModuleString *a, RedisModuleString *b);比较两个字符串对象，如果a <b，a == b，a> b，则分别返回-1、0或1。 字符串以两个二进制Blob的形式逐字节比较，而无需进行任何编码维护/整理。
RedisModule_StringAppendBuffer
int RedisModule_StringAppendBuffer(RedisModuleCtx *ctx, RedisModuleString *str, const char *buf, size_t len);将指定的缓冲区附加到字符串'str'。 该字符串必须是由用户创建的仅被引用一次的字符串，否则将返回REDISMODULE_ERR并且不执行该操作。
RedisModule_WrongArity
int RedisModule_WrongArity(RedisModuleCtx *ctx);
在错误消息中引用命令名称，以发送有关给该命令的参数数量的错误。
例：
if (argc != 3) return RedisModule_WrongArity(ctx);RedisModule_ReplyWithLongLong
int RedisModule_ReplyWithLongLong(RedisModuleCtx *ctx, long long ll);使用指定的long long值发送整数回复给客户端。 该函数始终返回REDISMODULE_OK。
RedisModule_ReplyWithError
int RedisModule_ReplyWithError(RedisModuleCtx *ctx, const char *err);回复错误“err”。
请注意，“err”必须包含所有错误，包括初始错误代码。 该函数仅提供首字母“-”，因此用法例如：
RedisModule_ReplyWithError(ctx,"ERR Wrong Type");而不仅仅是：
RedisModule_ReplyWithError(ctx,"Wrong Type");该函数始终返回REDISMODULE_OK。
RedisModule_ReplyWithSimpleString
int RedisModule_ReplyWithSimpleString(RedisModuleCtx *ctx, const char *msg);使用简单的字符串（在RESP协议中为+ ... \ r \ n）回复。 仅当发送开销较小的小型非二进制字符串（例如“OK”或类似的回复）时，此回复才适用。
该函数始终返回REDISMODULE_OK。
RedisModule_ReplyWithArray
int RedisModule_ReplyWithArray(RedisModuleCtx *ctx, long len);使用“len”元素的数组类型进行回复。 但是，必须跟随其他对ReplyWith *样式函数的调用才能发出数组的元素。
当生成的数组的元素数量事先未知时，可以使用特殊计数REDISMODULE_POSTPONED_ARRAY_LEN调用该函数，而实际的元素数量可以稍后通过RedisModule_ReplySetArrayLength()进行设置（如果存在，则将设置最新的“open”计数） 是多个）。
该函数始终返回REDISMODULE_OK。
RedisModule_ReplyWithNullArray
int RedisModule_ReplyWithNullArray(RedisModuleCtx *ctx);使用空数组回复客户端，在RESP3中简单为空，在RESP2中为空数组。
该函数始终返回REDISMODULE_OK。
RedisModule_ReplyWithEmptyArray
int RedisModule_ReplyWithEmptyArray(RedisModuleCtx *ctx);用空数组回复客户端。
该函数始终返回REDISMODULE_OK。
RedisModule_ReplySetArrayLength
void RedisModule_ReplySetArrayLength(RedisModuleCtx *ctx, long len);当RedisModule_ReplyWithArray()与参数REDISMODULE_POSTPONED_ARRAY_LEN一起使用时，由于我们事先不知道要输出为数组元素的项数，因此该函数将注意设置数组长度。
由于可能有多个长度未知的未决数组回复，因此此功能保证始终设置以延迟方式创建的最新数组长度。
例如，为了输出类似[1，[10,20,30]]的数组，我们可以这样写：
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请注意，在上面的示例中，由于我们生成了固定数量的元素，因此没有理由推迟数组长度，但是在实践中，代码可能会使用迭代器或其他方式来创建输出，因此在计算时不容易 提前元素数量。
RedisModule_ReplyWithStringBuffer
int RedisModule_ReplyWithStringBuffer(RedisModuleCtx *ctx, const char *buf, size_t len);使用大容量字符串回复，并输入C缓冲区指针和长度。
该函数始终返回REDISMODULE_OK。
RedisModule_ReplyWithCString
int RedisModule_ReplyWithCString(RedisModuleCtx *ctx, const char *buf);使用大容量字符串进行回复，并接受一个假定为空终止的C缓冲区指针。
该函数始终返回REDISMODULE_OK。
RedisModule_ReplyWithString
int RedisModule_ReplyWithString(RedisModuleCtx *ctx, RedisModuleString *str);使用大容量字符串进行回复，接受输入RedisModuleString对象。
该函数始终返回REDISMODULE_OK。
RedisModule_ReplyWithEmptyString
int RedisModule_ReplyWithEmptyString(RedisModuleCtx *ctx);使用空字符串回复。
该函数始终返回REDISMODULE_OK。
RedisModule_ReplyWithVerbatimString
int RedisModule_ReplyWithVerbatimString(RedisModuleCtx *ctx, const char *buf, size_t len);使用二进制安全字符串进行回复，不应接受输入C缓冲区指针和长度来对其进行转义或过滤。
该函数始终返回REDISMODULE_OK。
RedisModule_ReplyWithNull
int RedisModule_ReplyWithNull(RedisModuleCtx *ctx);使用NULL回复客户端。
该函数始终返回REDISMODULE_OK。
RedisModule_ReplyWithCallReply
int RedisModule_ReplyWithCallReply(RedisModuleCtx *ctx, RedisModuleCallReply *reply);使用RedisModule_Call()确切地回复Redis命令向我们返回的内容。 当我们使用RedisModule_Call()来执行某些命令时，此功能非常有用，因为我们希望对客户端的回复与命令所获得的回复完全相同。
该函数始终返回REDISMODULE_OK。
RedisModule_ReplyWithDouble
int RedisModule_ReplyWithDouble(RedisModuleCtx *ctx, double d);发送将双精度'd'转换为批量字符串获得的字符串回复。 此函数基本上等效于将double转换为字符串到C缓冲区，然后使用缓冲区和长度调用函数RedisModule_ReplyWithStringBuffer()。
该函数始终返回REDISMODULE_OK。
RedisModule_ReplyWithLongDouble
int RedisModule_ReplyWithLongDouble(RedisModuleCtx *ctx, long double ld);发送将长双精度'ld'转换为批量字符串获得的字符串回复。 此函数基本上等效于将一个long double转换为一个字符串放入C缓冲区，然后使用缓冲区和长度调用函数RedisModule_ReplyWithStringBuffer()。 双精度字符串使用人类可读的格式（请参见networking.c中的addReplyHumanLongDouble）。
该函数始终返回REDISMODULE_OK。
RedisModule_Replicate
int RedisModule_Replicate(RedisModuleCtx *ctx, const char *cmdname, const char *fmt, ...);将指定的命令和参数复制到从属设备和AOF，作为调用命令实现的执行效果。
复制的命令始终包装在MULTI / EXEC中，该文件包含在给定模块命令执行中复制的所有命令。 但是，使用RedisModule_Call()复制的命令是第一项，使用RedisModule_Replicate()复制的命令都将在EXEC之前执行。
模块应尝试使用一个接口或另一个接口。
此命令遵循与RedisModule_Call()完全相同的接口，因此必须传递一组格式说明符，后跟与提供的格式说明符匹配的参数。
请参考RedisModule_Call()以获得更多信息。
使用特殊的“A”和“R”修饰符，调用者可以从指定命令的传播中
关于从线程安全上下文调用此函数的注意事项：
通常，当你从实现模块命令的回调或Redis Module API提供的任何其他回调中调用此函数时，Redis会在回调的上下文中累积对该函数的所有调用，并将传播包装在 MULTI / EXEC事务。 但是，当从线程安全的上下文中调用此函数时，该线程的生存时间可能不确定，并且可以随意锁定/解锁，其行为是不同的：不会发出MULTI / EXEC包装器，并且将指定的命令插入到AOF中 并立即复制流。
返回值
如果格式说明符无效或命令名称不属于已知命令，则该命令返回REDISMODULE_ERR。
RedisModule_ReplicateVerbatim
int RedisModule_ReplicateVerbatim(RedisModuleCtx *ctx);此函数将完全复制客户端调用的命令。 请注意，此功能不会将命令包装到MULTI / EXEC节中，因此不应与其他复制命令混合使用。
基本上，当你要将命令准确地传播到从属文件和AOF文件时，这种复制形式非常有用，因为只需重新执行命令即可确定性地从旧状态重新创建新状态。
该函数始终返回REDISMODULE_OK。
RedisModule_GetClientId
unsigned long long RedisModule_GetClientId(RedisModuleCtx *ctx);返回调用当前活动模块命令的当前客户端的ID。 返回的ID有一些保证：
- 每个不同客户端的ID均不同，因此，如果同一客户端多次执行模块命令，则可以将其识别为具有相同的ID，否则该ID将有所不同。
- ID单调增加。 保证以后连接到服务器的客户端获得的ID大于以前看到的任何过去的ID。
有效ID从1到2的64-1幂。 如果返回0，则意味着无法在当前调用该函数的上下文中获取ID。
获取ID后，可以使用以下宏检查在AOF加载的上下文中命令执行是否确实发生：
if (RedisModule_IsAOFClient(RedisModule_GetClientId(ctx)) {
// Handle it differently.
}RedisModule_GetClientInfoById
int RedisModule_GetClientInfoById(void *ci, uint64_t id);返回有关具有指定ID（先前是通过RedisModule_GetClientId()API获得的）的客户端的信息。 如果客户端存在，则返回REDISMODULE_OK，否则返回REDISMODULE_ERR。
当客户端存在并且ci指针不是NULL，而是指向RedisModuleClientInfo类型的结构时，该结构先前已使用正确的REDISMODULE_CLIENTINFO_INITIALIZER初始化，该结构将填充以下字段：
uint64_t flags; // REDISMODULE_CLIENTINFO_FLAG_*
uint64_t id; // Client ID
char addr[46]; // IPv4 or IPv6 address.
uint16_t port; // TCP port.
uint16_t db; // Selected DB.注意：客户ID在此调用的上下文中是无用的，因为我们已经知道了，但是在我们不知道客户ID的其他上下文中也可以使用相同的结构，但是会返回相同的结构。
具有以下含义的标志：
REDISMODULE_CLIENTINFO_FLAG_SSL Client using SSL connection.
REDISMODULE_CLIENTINFO_FLAG_PUBSUB Client in Pub/Sub mode.
REDISMODULE_CLIENTINFO_FLAG_BLOCKED Client blocked in command.
REDISMODULE_CLIENTINFO_FLAG_TRACKING Client with keys tracking on.
REDISMODULE_CLIENTINFO_FLAG_UNIXSOCKET Client using unix domain socket.
REDISMODULE_CLIENTINFO_FLAG_MULTI Client in MULTI state.但是，如果我们对任何其他信息不感兴趣，则传递NULL是一种仅检查客户端是否存在的方法。
当我们希望返回客户信息结构时，这是正确的用法：
RedisModuleClientInfo ci = REDISMODULE_CLIENTINFO_INITIALIZER;
int retval = RedisModule_GetClientInfoById(&ci,client_id);
if (retval == REDISMODULE_OK) {
printf("Address: %s\n", ci.addr);
}RedisModule_PublishMessage
int RedisModule_PublishMessage(RedisModuleCtx *ctx, RedisModuleString *channel, RedisModuleString *message);向订阅者发布消息（请参阅PUBLISH命令）。
RedisModule_GetSelectedDb
int RedisModule_GetSelectedDb(RedisModuleCtx *ctx);返回当前选择的数据库。
RedisModule_GetContextFlags
int RedisModule_GetContextFlags(RedisModuleCtx *ctx);返回当前上下文的标志。 这些标志提供有关当前请求上下文（客户端是Lua脚本还是MULTI）的信息，以及有关Redis实例的信息，即复制和持久性。
即使在NULL上下文中也可以调用此函数，但是在这种情况下，将不会报告以下标志：
- LUA, MULTI, REPLICATED, DIRTY (see below for more info).
可用标志及其含义：
-
REDISMODULECTXFLAGS_LUA: 该命令正在Lua脚本中运行
-
REDISMODULECTXFLAGS_MULTI: 该命令正在事务内运行
-
REDISMODULECTXFLAGS_REPLICATED: 该命令是由MASTER通过复制链接发送的
-
REDISMODULECTXFLAGS_MASTER: Redis实例是主节点
-
REDISMODULECTXFLAGS_SLAVE: Redis实例是从节点
-
REDISMODULECTXFLAGS_READONLY: Redis实例是只读的
-
REDISMODULECTXFLAGS_CLUSTER: Redis实例处于集群模式
-
REDISMODULECTXFLAGS_AOF: Redis实例启用了AOF
-
REDISMODULECTXFLAGS_RDB: 实例已启用RDB
-
REDISMODULECTXFLAGS_MAXMEMORY: 实例已设置Maxmemory
-
REDISMODULECTXFLAGS_EVICT: Maxmemory已设置并具有逐出策略，可能会删除密钥
-
REDISMODULECTXFLAGS_OOM: 根据最大内存设置，Redis内存不足。
-
REDISMODULECTXFLAGSOOMWARNING: 达到最大内存级别之前，剩余的内存不足25％。
-
REDISMODULECTXFLAGS_LOADING: 服务器正在加载RDB / AOF
-
REDISMODULECTXFLAGSREPLICAIS_STALE: 与主节点没有活动链接。
-
REDISMODULECTXFLAGSREPLICAIS_CONNECTING: 副本正在尝试与主节点连接。
-
REDISMODULECTXFLAGSREPLICAIS_TRANSFERRING: Master -> Replica RDB 传输在进程中.
-
REDISMODULECTXFLAGSREPLICAIS_ONLINE: 副本与其主节点具有活动链接。 这与STALE状态相反。
-
REDISMODULECTXFLAGSACTIVECHILD: 当前有一些后台进程处于活动状态（RDB，AUX或模块）。
-
REDISMODULECTXFLAGSMULTIDIRTY: 下一个EXEC将由于CAS（触摸键）变脏而失败。
-
REDISMODULECTXFLAGSISCHILD: Redis当前在后台子进程中运行。
RedisModule_AvoidReplicaTraffic
int RedisModule_AvoidReplicaTraffic();如果某些客户端向服务器发送了CLIENT PAUSE命令，或者Redis Cluster正在执行手动故障转移并暂停了tue客户端，则返回true。 当我们有一个具有副本的主数据库，并且想要在不向复制通道添加更多数据的情况下进行写入时，需要复制副本的偏移与主数据库之一匹配，这是必需的。 发生这种情况时，可以安全地对主节点进行故障转移而不会丢失数据。
但是，模块可以通过使用"!" 调用RedisModule_Call()来生成流量。 标志，或者在命令执行之外的上下文中调用RedisModule_Replicate()，例如在超时回调，线程安全上下文等中。 当模块产生的流量过多时，将很难匹配主节点副本和副本偏移量，因为复制通道中有更多数据要发送。
因此，当此函数返回true时，模块可能希望尝试避免进行大量繁重的后台工作，这些工作会影响向复制通道创建数据。 这对于具有后台垃圾回收任务或确实在计时器回调或其他周期性回调中进行写入和复制此类写入的模块非常有用。
RedisModule_SelectDb
int RedisModule_SelectDb(RedisModuleCtx *ctx, int newid);更改当前选择的数据库。 如果ID超出范围，则返回错误。
请注意，即使调用此函数的模块实现的Redis命令返回后，客户端仍将保留当前选择的DB。
如果模块命令希望更改其他数据库中的某些内容并返回到原来的数据库，则应先调用 RedisModule_GetSelectedDb() 以便在返回之前恢复旧的数据库号。
RedisModule_OpenKey
void *RedisModule_OpenKey(RedisModuleCtx *ctx, robj *keyname, int mode);返回表示Redis键的句柄，以便可以使用键句柄作为参数来调用其他API，以对键执行操作。
返回值是代表键的句柄，必须使用RM_CloseKey()将其关闭。
如果键不存在，并且请求了WRITE模式，则仍将返回该句柄，因为可以对尚不存在的键执行操作（例如，将在列表推送操作之后创建）。 如果模式仅是READ，而键不存在，则返回NULL。 但是，在NULL值上调用RedisModule_CloseKey()和RedisModule_KeyType()仍然是安全的。
RedisModule_CloseKey
void RedisModule_CloseKey(RedisModuleKey *key);关闭一个键句柄。
RedisModule_KeyType
int RedisModule_KeyType(RedisModuleKey *key);返回键的类型。 如果键指针为NULL，则返回REDISMODULE_KEYTYPE_EMPTY。
RedisModule_ValueLength
size_t RedisModule_ValueLength(RedisModuleKey *key);返回与键关联的值的长度。 对于字符串，这是字符串的长度。 对于所有其他类型，是元素的数量（仅对哈希键进行计数）。
如果键指针为NULL或键为空，则返回零。
RedisModule_DeleteKey
int RedisModule_DeleteKey(RedisModuleKey *key);如果该键已打开以进行写入，请将其删除，然后将其设置为接受新的写入作为空键（将按需创建）。 成功后，将返回REDISMODULE_OK。 如果未打开写入键，则返回REDISMODULE_ERR。
RedisModule_UnlinkKey
int RedisModule_UnlinkKey(RedisModuleKey *key);如果该键已打开以进行写入，请取消链接（即以非阻塞方式将其删除，而不是立即回收内存），然后将该键设置为接受新写入作为空键（将按需创建）。 成功后，将返回REDISMODULE_OK。 如果未打开写入键，则返回REDISMODULE_ERR。
RedisModule_GetExpire
mstime_t RedisModule_GetExpire(RedisModuleKey *key);返回键到期值，以剩余TTL的毫秒数为单位。 如果没有与该键关联的TTL或该键为空，则返回REDISMODULE_NO_EXPIRE。
RedisModule_SetExpire
int RedisModule_SetExpire(RedisModuleKey *key, mstime_t expire);设置新的键过期。 如果设置了特殊过期时间REDISMODULE_NO_EXPIRE，则如果存在一个特殊过期时间（与PERSIST命令相同），则取消该过期时间。
请注意，expire必须以正整数形式提供，代表键应该具有的TTL的毫秒数。
该函数成功返回REDISMODULE_OK，如果键没有打开以供写入或为空键，则返回REDISMODULE_ERR。
RedisModule_ResetDataset
void RedisModule_ResetDataset(int restart_aof, int async);执行与FLUSHALL类似的操作，并有选择地启动新的AOF文件（如果启用）（如果启用），如果restart_aof为true，则必须确保触发此调用的命令不会传播到AOF文件。 当async设置为true时，后台线程将释放数据库内容。
RedisModule_DbSize
unsigned long long RedisModule_DbSize(RedisModuleCtx *ctx);返回当前数据库中的键数。
RedisModule_RandomKey
RedisModuleString *RedisModule_RandomKey(RedisModuleCtx *ctx);返回随机键的名称，如果当前数据库为空，则返回NULL。
RedisModule_StringSet
int RedisModule_StringSet(RedisModuleKey *key, RedisModuleString *str);如果打开了可写的键，则将指定的字符串'str'设置为键的值，并删除旧值（如果有）。 成功后，将返回REDISMODULE_OK。 如果密钥未打开以进行写入或有活动的迭代器，则返回REDISMODULE_ERR。
RedisModule_StringDMA
char *RedisModule_StringDMA(RedisModuleKey *key, size_t *len, int mode);准备用于DMA访问的与键相关的字符串值，并返回一个指针和大小（通过引用），用户可以使用该指针和大小直接通过指针访问或就地访问字符串来修改字符串。
“mode”由以下标志按位或组成：
REDISMODULE_READ -- Read access
REDISMODULE_WRITE -- Write access如果不请求DMA写入，则返回的指针应仅以只读方式访问。
错误（类型错误）返回NULL。
DMA访问规则：
- 自从获得指针的那一刻起，我们一直想使用DMA访问来读取或修改字符串，因此不应调用其他任何键写入函数。
- 每次调用RM_StringTruncate()时，要继续进行DMA访问，应再次调用RM_StringDMA()以重新获得新的指针和长度。
- 如果返回的指针不是NULL，但是长度为零，则不能触摸任何字节（字符串为空，或者键本身为空），因此，如果要扩大字符串，则应使用RM_StringTruncate()调用，并且 稍后再次调用StringDMA()以获取指针。
RedisModule_StringTruncate
int RedisModule_StringTruncate(RedisModuleKey *key, size_t newlen);如果字符串是开放的并且是字符串类型，请调整其大小，如果新长度大于旧长度，则以零字节填充。
调用之后，必须再次调用RM_StringDMA()才能继续使用新指针进行DMA访问。
该函数在成功时返回REDISMODULE_OK，在错误时返回REDISMODULE_ERR，即，该键未打开以进行写入，不是字符串或请求的大小超过512 MB。
如果键为空，则除非新的长度要求为零，否则将使用新的字符串值创建一个字符串键。
RedisModule_ListPush
int RedisModule_ListPush(RedisModuleKey *key, int where, RedisModuleString *ele);根据“where”参数，将元素按头或尾推入列表。 如果键指针是关于要写入的空键，则创建键。 错误时（为只读操作打开的键或错误类型的键）返回REDISMODULE_ERR，否则返回REDISMODULE_OK。
RedisModule_ListPop
RedisModuleString *RedisModule_ListPop(RedisModuleKey *key, int where);从列表中弹出一个元素，并将其作为模块字符串对象返回，用户应该使用RM_FreeString()或通过启用自动内存来释放该元素。 'where'指定从头还是尾弹出元素。 如果出现以下情况，该命令将返回NULL：
- 列表为空。
- 密钥未打开以进行写入。
- 密钥不是列表。
RedisModule_ZsetAddFlagsToCoreFlags
int RedisModule_ZsetAddFlagsToCoreFlags(int flags);from/to Modules API的公共标志和我们的私有标志之间进行转换，这样我们就可以将所有事物分离。
RedisModule_ZsetAddFlagsFromCoreFlags
int RedisModule_ZsetAddFlagsFromCoreFlags(int flags);请参阅先前的功能注释。
RedisModule_ZsetAdd
int RedisModule_ZsetAdd(RedisModuleKey *key, double score, RedisModuleString *ele, int *flagsptr);使用指定的“score”将新元素添加到排序集中。 如果该元素已经存在，则更新分数。
如果键是用于写入的空打开键设置，则将在value处创建一个新的排序集。
可以通过指针将其他标志传递给函数，这些标志既用于接收输入，又在函数返回时用于传递状态。 如果不使用特殊标志，则'flagsptr'可以为NULL。
输入标志是：
REDISMODULE_ZADD_XX: Element must already exist. Do nothing otherwise.
REDISMODULE_ZADD_NX: Element must not exist. Do nothing otherwise.
REDISMODULE_ZADD_LT: For existing element, only update if the new score is less than the current score.
REDISMODULE_ZADD_GT: For existing element, only update if the new score is greater than the current score.输出标志是：
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.成功后，函数将返回REDISMODULE_OK。 在以下错误中，返回REDISMODULE_ERR：
- 键尚未打开以进行写入。
- 键类型错误。
- “score”双精度值不是数字（NaN）。
RedisModule_ZsetIncrby
int RedisModule_ZsetIncrby(RedisModuleKey *key, double score, RedisModuleString *ele, int *flagsptr, double *newscore);此函数的工作原理与RM_ZsetAdd()完全相同，但是不设置新的分数，而是增加现有元素的分数，或者如果该元素不存在，则在假定旧分数为零的情况下添加它。
输入和输出标志以及返回值具有相同的确切含义，唯一的区别是，即使'score'是有效的双精度数，该函数也将返回REDISMODULE_ERR，但将其添加到现有分数中会得出NaN（ 不是数字）条件。
如果不返回NULL，则该函数具有一个附加字段'newscore'，如果不为NULL，则在增量后用元素的新分数填充。
RedisModule_ZsetRem
int RedisModule_ZsetRem(RedisModuleKey *key, RedisModuleString *ele, int *deleted);从排序集中删除指定的元素。 该函数成功返回REDISMODULE_OK，并在以下情况之一返回REDISMODULE_ERR：
- 键尚未打开以进行写入。
- 键类型错误。
返回值并不表示实际上是否已经删除了该元素（因为该元素存在），即使该函数已成功执行。
为了知道是否删除了该元素，必须传递附加的参数“deleted”，该参数根据操作结果通过引用将其设置为1或0来填充整数。 如果调用者不希望知道元素是否已真正删除，则“deleted”参数可以为NULL。
不执行任何操作将正确处理空键。
RedisModule_ZsetScore
int RedisModule_ZsetScore(RedisModuleKey *key, RedisModuleString *ele, double *score);成功后，检索在排序的集合元素“ele”处关联的双分数，并返回REDISMODULE_OK。 否则，返回REDISMODULE_ERR以发出以下情况之一的信号：
- 排序集中没有这样的元素“ele”。
- 键不是排序集。
- 该键是一个打开的空键。
RedisModule_ZsetRangeStop
void RedisModule_ZsetRangeStop(RedisModuleKey *key);停止排序的集合迭代。
RedisModule_ZsetRangeEndReached
int RedisModule_ZsetRangeEndReached(RedisModuleKey *key);返回“End of range”标志值，以信号指示迭代结束。
RedisModule_ZsetFirstInScoreRange
int RedisModule_ZsetFirstInScoreRange(RedisModuleKey *key, double min, double max, int minex, int maxex);设置一个排序集合迭代器，以查找指定范围内的第一个元素。 如果正确初始化了迭代器，则返回REDISMODULE_OK，否则在以下情况下返回REDISMODULE_ERR：
- 键处存储的值不是排序集，或者键为空。
根据两个双精度值“min”和“max”指定范围。 使用以下两个宏，两者都可以是无限的：
REDISMODULE_POSITIVE_INFINITE为正无穷大REDISMODULE_NEGATIVE_INFINITE为负无穷大
如果“minex”和“maxex”参数为true，则分别设置一个范围，其中最小值和最大值是互斥的（不包括在内）而不是互斥的。
RedisModule_ZsetLastInScoreRange
int RedisModule_ZsetLastInScoreRange(RedisModuleKey *key, double min, double max, int minex, int maxex);与RedisModule_ZsetFirstInScoreRange()完全一样，但是选择范围的最后一个元素作为迭代的开始。
RedisModule_ZsetFirstInLexRange
int RedisModule_ZsetFirstInLexRange(RedisModuleKey *key, RedisModuleString *min, RedisModuleString *max);设置一个排序集合迭代器，该迭代器在指定的字典范围内搜索第一个元素。 如果正确初始化了迭代器，则返回REDISMODULE_OK，否则在以下情况下返回REDISMODULE_ERR：
- 键处存储的值不是排序集，或者键为空。
- 字典范围的“min”和“max”格式无效。
“min”和“max”应作为两个RedisModuleString对象提供，格式与传递给ZRANGEBYLEX命令的参数相同。 该函数不拥有对象的所有权，因此可以在设置迭代器后尽快释放它们。
RedisModule_ZsetLastInLexRange
int RedisModule_ZsetLastInLexRange(RedisModuleKey *key, RedisModuleString *min, RedisModuleString *max);与RedisModule_ZsetFirstInLexRange()完全一样，但是选择范围的最后一个元素作为迭代的开始。
RedisModule_ZsetRangeCurrentElement
RedisModuleString *RedisModule_ZsetRangeCurrentElement(RedisModuleKey *key, double *score);返回活动排序集合迭代器的当前排序集合元素，如果迭代器中指定的范围不包含任何元素，则返回NULL。
RedisModule_ZsetRangeNext
int RedisModule_ZsetRangeNext(RedisModuleKey *key);转到已排序的集合迭代器的下一个元素。 如果存在下一个元素，则返回1；如果我们已经是最新元素，或者范围完全不包含任何项目，则返回0。
RedisModule_ZsetRangePrev
int RedisModule_ZsetRangePrev(RedisModuleKey *key);转到已排序的集合迭代器的上一个元素。 如果存在前一个元素，则返回1；如果我们已经位于第一个元素中，或者范围完全不包含任何项目，则返回0。
RedisModule_HashSet
int RedisModule_HashSet(RedisModuleKey *key, int flags, ...);将指定的哈希字段的字段设置为指定的值。 如果该键是打开的用于写操作的空键，则会使用一个空的哈希值创建该键，以设置指定的字段。
该函数是可变参数，用户必须指定成对的字段名称和值，它们均作为RedisModuleString指针（除非设置了CFIELD选项，请参阅下文）。 在字段/值-ptr对的末尾，必须将NULL指定为最后一个参数，以表示可变参数函数中参数的结尾。
将哈希argv [1]设置为值argv [2]的示例：
RedisModule_HashSet(key,REDISMODULE_HASH_NONE,argv[1],argv[2],NULL);通过将字段设置为REDISMODULE_HASH_DELETE的指定值，还可以使用该函数来删除字段（如果存在）：
RedisModule_HashSet(key,REDISMODULE_HASH_NONE,argv[1],
REDISMODULE_HASH_DELETE,NULL);命令的行为会随着指定的标志而更改，如果不需要特殊行为，可以将其设置为REDISMODULE_HASH_NONE。
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.除非指定了NX，否则该命令将用新字段覆盖旧的字段值。
当使用REDISMODULE_HASH_CFIELDS时，字段名称是使用常规C字符串报告的，因此例如，要删除字段“foo”，可以使用以下代码：
RedisModule_HashSet(key,REDISMODULE_HASH_CFIELDS,"foo",
REDISMODULE_HASH_DELETE,NULL);返回值：
更新的字段数（由于XX或NX选项，可能少于指定的字段数）。
在以下情况下，返回值始终为零：
- 键没有打开可写。
- 键与非哈希值关联。
RedisModule_HashGet
int RedisModule_HashGet(RedisModuleKey *key, int flags, ...);从哈希值获取字段。 使用可变数量的参数调用此函数，将字段名（作为RedisModuleString指针）与指向RedisModuleString指针的指针交替，如果该字段存在，则设置为该字段的值；如果该字段不存在，则设置为NULL 存在。 在字段/值-ptr对的末尾，必须将NULL指定为最后一个参数，以表示可变参数函数中参数的结尾。
这是一个示例用法：
RedisModuleString *first, *second;
RedisModule_HashGet(mykey,REDISMODULE_HASH_NONE,argv[1],&first,
argv[2],&second,NULL);与RedisModule_HashSet()一样，可以通过传递与REDISMODULE_HASH_NONE不同的标志来指定命令的行为：
REDISMODULE_HASH_CFIELDS：字段名称为以空终止的C字符串。
REDISMODULE_HASH_EXISTS：该函数没有设置期望RedisModuleString指针指向该指针的字段的值，而是仅报告该字段是否存在，并希望使用整数指针作为每对的第二个元素。
REDISMODULE_HASH_CFIELDS的示例：
RedisModuleString *username, *hashedpass;
RedisModule_HashGet(mykey,REDISMODULE_HASH_CFIELDS,"username",&username,"hp",&hashedpass, NULL);REDISMODULE_HASH_EXISTS的示例：
int exists;
RedisModule_HashGet(mykey,REDISMODULE_HASH_EXISTS,argv[1],&exists,NULL);如果成功，则函数返回REDISMODULE_OK，如果键不是哈希值，则返回REDISMODULE_ERR。
内存管理：
返回的RedisModuleString对象应通过RedisModule_FreeString（）或通过启用自动内存管理来释放。
RedisModule_FreeCallReply_Rec
void RedisModule_FreeCallReply_Rec(RedisModuleCallReply *reply, int freenested);如果是数组，则释放Call 回复和它包含的所有嵌套回复。
RedisModule_FreeCallReply
void RedisModule_FreeCallReply(RedisModuleCallReply *reply);包装器，用于递归免费回复功能。 为了使第一级函数能够返回嵌套回复，这是必需的，但仅在模块API调用时才需要。
RedisModule_CallReplyType
int RedisModule_CallReplyType(RedisModuleCallReply *reply);返回回复类型。
RedisModule_CallReplyLength
size_t RedisModule_CallReplyLength(RedisModuleCallReply *reply);返回回复类型的长度（如果适用）。
RedisModule_CallReplyArrayElement
RedisModuleCallReply *RedisModule_CallReplyArrayElement(RedisModuleCallReply *reply, size_t idx);返回数组应答的第“idx”个嵌套调用应答元素，如果应答类型错误或索引超出范围，则返回NULL。
RedisModule_CallReplyInteger
long long RedisModule_CallReplyInteger(RedisModuleCallReply *reply);返回整数回复的long long。
RedisModule_CallReplyStringPtr
const char *RedisModule_CallReplyStringPtr(RedisModuleCallReply *reply, size_t *len);返回指针和字符串的长度或错误回复。
RedisModule_CreateStringFromCallReply
RedisModuleString *RedisModule_CreateStringFromCallReply(RedisModuleCallReply *reply);从字符串，错误或整数类型的呼叫回复中返回新的字符串对象。 否则（错误的回复类型）返回NULL。
RedisModule_Call
RedisModuleCallReply *RedisModule_Call(RedisModuleCtx *ctx, const char *cmdname, const char *fmt, ...);导出的API可从模块调用任何Redis命令。
- cmdname: Redis命令调用。
- fmt: 命令参数的格式说明符字符串。 每个参数都应由有效的类型规范指定：b该参数是一个缓冲区，紧随其后的是另一个参数，即缓冲区的长度。 c该参数是一个指向纯C字符串（以Null终止）的指针。 l参数是long long integer。参数是RedisModuleString。 v参数是RedisModuleString的向量。
格式说明符还可以包含修饰符：!
将Redis命令及其参数发送到副本和AOF。 禁止AOF传播，仅发送到副本（要求!）。 R禁止复制副本传播，仅发送到AOF（需要!）。 * ...：Redis命令的实际参数。
成功后，将返回RedisModuleCallReply对象，否则返回NULL并将errno设置为以下值：
- EBADF：格式说明符错误。
- EINVAL：错误的命令错误。
- ENOENT：命令不存在。
- EPERM：在群集实例中的操作，其中密钥位于非本地插槽中。
- EROFS：以只读状态发送写命令时在集群实例中的操作。
- ENETDOWN：群集关闭时在群集实例中的操作。
示例代码片段：
reply = RedisModule_Call(ctx,"INCRBY","sc",argv[1],"10");
if (RedisModule_CallReplyType(reply) == REDISMODULE_REPLY_INTEGER) {
long long myval = RedisModule_CallReplyInteger(reply);
// Do something with myval.
}示例代码片段：
reply = RedisModule_Call(ctx,"INCRBY","sc",argv[1],"10");
if (RedisModule_CallReplyType(reply) == REDISMODULE_REPLY_INTEGER) {
long long myval = RedisModule_CallReplyInteger(reply);
// Do something with myval.
}此API记录在这里：https://redis.io/topics/modules-intro
RedisModule_CallReplyProto
const char *RedisModule_CallReplyProto(RedisModuleCallReply *reply, size_t *len);返回指向返回回复对象的命令所返回协议的指针和长度。
RedisModule_CreateDataType
moduleType *RedisModule_CreateDataType(RedisModuleCtx *ctx, const char *name, int encver, void *typemethods_ptr);注册模块导出的新数据类型。 参数如下。 请深入了解模块API文档，尤其是https://redis.io/topics/modules-native-types。
- name: 一个9个字符的数据类型名称，在Redis Modules生态系统中必须唯一。 有创造力...不会有冲突。 使用字符集A-Z a-z 9-0，再加上两个“ -_”字符。 一个好主意是使用，例如<typename>-<vendor>。 例如，“tree-AntZ”可能表示“ @antirez的树数据结构”。 同时使用小写和大写字母有助于防止冲突。
- encver: 编码版本，即模块用来保留数据的序列化版本。 只要“名称”匹配，无论使用哪种“encver”，RDB的加载都会被分派到类型回调中，但是模块可以理解它是否必须加载的编码是模块的旧版本。 例如，模块“tree-AntZ”最初使用encver = 0。 升级之后，它开始以另一种格式序列化数据并将其类型注册为encver = 1。 但是，如果rdb_load回调能够检查encver值并采取相应措施，则此模块仍可以加载由较旧版本生成的旧数据。 编码器必须为0到1023之间的正值。
-
typemethods_ptr 是指向RedisModuleTypeMethods结构的指针，该结构应使用方法回调和结构版本填充，如以下示例所示：
RedisModuleTypeMethods tm = { .version = REDISMODULETYPEMETHODVERSION, .rdbload = myTypeRDBLoadCallBack, .rdbsave = myTypeRDBSaveCallBack, .aofrewrite = myTypeAOFRewriteCallBack, .free = myTypeFreeCallBack,
// Optional fields
.digest = myType_DigestCallBack,
.mem_usage = myType_MemUsageCallBack,
.aux_load = myType_AuxRDBLoadCallBack,
.aux_save = myType_AuxRDBSaveCallBack,-
rdb_load: 一个从RDB文件加载数据的回调函数指针。
-
rdb_save: 将数据保存到RDB文件的回调函数指针。
-
aof_rewrite: 一个将数据重写为命令的回调函数指针。
-
digest: 用于DEBUG DIGEST的回调函数指针。
-
free: 可以释放类型值的回调函数指针
-
aux_save: 一个回调函数指针，可将键空间数据之外的数据保存到RDB文件中。 “when”参数为REDISMODULEAUXBEFORERDB或REDISMODULEAUXAFTERRDB。
-
aux_load: 一个回调函数指针，该指针从RDB文件中加载键空间数据。 与auxsave相似，成功时返回REDISMODULEOK，否则返回ERR。
目前，digest和mem_usage方法应该被省略，因为它们尚未在Redis模块核心中实现。
注意：模块名称“ AAAAAAAAA”已保留并产生错误，它也很la脚。
如果已经有一个模块注册了相同名称的类型，并且模块名称或encver无效，则返回NULL。 否则，将新类型注册到Redis中，并返回类型RedisModuleType的引用：函数的调用者应将此引用存储到全局变量中，以便将来在模块类型API中使用它，因为单个模块可以注册多个 类型。 示例代码片段：
static RedisModuleType *BalancedTreeType;
int RedisModule_OnLoad(RedisModuleCtx *ctx) {
// some code here ...
BalancedTreeType = RM_CreateDataType(...);
}RedisModule_ModuleTypeSetValue
int RedisModule_ModuleTypeSetValue(RedisModuleKey *key, moduleType *mt, void *value);如果打开了用于写入的键，则将指定的模块类型对象设置为键的值，并删除旧值（如果有）。 成功后，将返回REDISMODULE_OK。 如果键未打开以进行写入或有活动的迭代器，则返回REDISMODULE_ERR。
RedisModule_ModuleTypeGetType
moduleType *RedisModule_ModuleTypeGetType(RedisModuleKey *key);假设RedisModule_KeyType()在键上返回REDISMODULE_KEYTYPE_MODULE，则返回存储在键上的值的模块类型指针。
如果键为NULL，与模块类型不相关或为空，则返回NULL。
RedisModule_ModuleTypeGetValue
void *RedisModule_ModuleTypeGetValue(RedisModuleKey *key);假设RedisModule_KeyType()在键上返回REDISMODULE_KEYTYPE_MODULE，则返回存储在键上的模块类型低级别值，该值是由用户通过RedisModule_ModuleTypeSetValue()设置的。
如果键为NULL，与模块类型不相关或为空，则返回NULL。
RedisModule_IsIOError
int RedisModule_IsIOError(RedisModuleIO *io);如果任何先前的IO API失败，则返回true。 对于Load * API，必须首先使用RedisModule_SetModuleOptions设置REDISMODULE_OPTIONS_HANDLE_IO_ERRORS标志。
RedisModule_SaveUnsigned
void RedisModule_SaveUnsigned(RedisModuleIO *io, uint64_t value);将无符号的64位值保存到RDB文件中。 仅应在实现新数据类型的模块的rdb_save方法的上下文中调用此函数。
RedisModule_LoadUnsigned
uint64_t RedisModule_LoadUnsigned(RedisModuleIO *io);从RDB文件中加载一个无符号的64位值。 仅在实现新数据类型的模块的rdb_load方法的上下文中调用此函数。
RedisModule_SaveSigned
void RedisModule_SaveSigned(RedisModuleIO *io, int64_t value);类似于RedisModule_SaveUnsigned()，但用于带符号的64位值。
RedisModule_LoadSigned
int64_t RedisModule_LoadSigned(RedisModuleIO *io);类似于RedisModule_LoadUnsigned()，但用于带符号的64位值。
RedisModule_SaveString
void RedisModule_SaveString(RedisModuleIO *io, RedisModuleString *s);在模块类型的rdb_save方法的上下文中，使用RedisModuleString作为输入将字符串保存到RDB文件中。
以后可以使用RedisModule_LoadString()或其他Load系列函数加载该字符串，并且需要在RDB文件中使用序列化的字符串。
RedisModule_SaveStringBuffer
void RedisModule_SaveStringBuffer(RedisModuleIO *io, const char *str, size_t len);像RedisModule_SaveString()一样，但是使用原始的C指针和长度作为输入。
RedisModule_LoadString
RedisModuleString *RedisModule_LoadString(RedisModuleIO *io);在模块数据类型的rdb_load方法的上下文中，从RDB文件中加载一个字符串，该字符串以前是用RedisModule_SaveString()函数族保存的。
返回的字符串是新分配的RedisModuleString对象，用户应在某个时候通过调用RedisModule_FreeString()释放它。
如果数据结构未将字符串存储为RedisModuleString对象，则可以改用类似的函数RedisModule_LoadStringBuffer()。
RedisModule_LoadStringBuffer
char *RedisModule_LoadStringBuffer(RedisModuleIO *io, size_t *lenptr);与RedisModule_LoadString()类似，但是返回堆分配的字符串，该字符串是通过RedisModule_Alloc()分配的，可以使用RedisModule_Realloc()或RedisModule_Free()进行大小调整或释放。
如果不为NULL，则字符串的大小存储在'* lenptr'中。 返回的字符串不是自动以NULL终止的，它的加载方式与存储在RDB文件中的方式完全相同。
RedisModule_SaveDouble
void RedisModule_SaveDouble(RedisModuleIO *io, double value);在模块数据类型的rdb_save方法的上下文中，将双精度值保存到RDB文件。 双精度数可以是有效数字，NaN或无穷大。 可以使用RedisModule_LoadDouble()加载回该值。
RedisModule_LoadDouble
double RedisModule_LoadDouble(RedisModuleIO *io);在模块数据类型的rdb_save方法的上下文中，加载回RedisModule_SaveDouble()保存的double值。
RedisModule_SaveFloat
void RedisModule_SaveFloat(RedisModuleIO *io, float value);在模块数据类型的rdb_save方法的上下文中，将浮点值保存到RDB文件。 浮点数可以是有效数字，NaN或无穷大。 可以使用RedisModule_LoadFloat()加载该值。
RedisModule_LoadFloat
float RedisModule_LoadFloat(RedisModuleIO *io);在模块数据类型的rdb_save方法的上下文中，加载回RedisModule_SaveFloat()保存的float值。
RedisModule_SaveLongDouble
void RedisModule_SaveLongDouble(RedisModuleIO *io, long double value);在模块数据类型的rdb_save方法的上下文中，将一个较长的double值保存到RDB文件中。 双精度数可以是有效数字，NaN或无穷大。 可以使用RedisModule_LoadLongDouble()加载该值。
RedisModule_LoadLongDouble
long double RedisModule_LoadLongDouble(RedisModuleIO *io);在模块数据类型的rdb_save方法的上下文中，加载回RedisModule_SaveLongDouble()保存的long double值。
RedisModule_DigestAddStringBuffer
void RedisModule_DigestAddStringBuffer(RedisModuleDigest *md, unsigned char *ele, size_t len);向摘要添加一个新元素。 对于组成给定数据结构的所有元素，可以一个元素接一个元素多次调用此函数。 当添加了始终以给定顺序排列的所有元素时，最终必须在函数调用之后调用RedisModule_DigestEndSequence。 有关更多信息，请参见Redis模块数据类型文档。 但是，这是一个快速示例，以Redis数据类型为例。
要添加一系列无序元素（例如，在Redis Set的情况下），使用的模式是：
foreach element {
AddElement(element);
EndSequence();
}由于Sets是无序的，因此添加的每个元素的位置都不相互依赖。 但是，如果相反我们的元素是成对排列的，例如哈希的字段值对，则应该使用：
foreach key,value {
AddElement(key);
AddElement(value);
EndSquence();
}由于键和值始终按上述顺序排列，因此单个键值对可以在Redis哈希中的任何位置出现。
有序元素列表将通过以下方式实现：
foreach element {
AddElement(element);
}
EndSequence();RedisModule_DigestAddLongLong
void RedisModule_DigestAddLongLong(RedisModuleDigest *md, long long ll);就像RedisModule_DigestAddStringBuffer()一样，但是将输入转换为字符串之前需要很长时间才能将其添加到摘要中。
RedisModule_DigestEndSequence
void RedisModule_DigestEndSequence(RedisModuleDigest *md);请参阅有关RedisModule_DigestAddElement()的文档。
RedisModule_EmitAOF
void RedisModule_EmitAOF(RedisModuleIO *io, const char *cmdname, const char *fmt, ...);在AOF重写过程中向AOF发出命令。 仅在模块导出的数据类型的aof_rewrite方法的上下文中调用此函数。 该命令的传递方式与RedisModule_Call()完全相同，但是由于Redis本身执行了错误处理，因此该命令不会返回任何内容。
RedisModule_GetKeyNameFromIO
const RedisModuleString *RedisModule_GetKeyNameFromIO(RedisModuleIO *io);调用IO数据类型回调时，返回带有当前正在保存或正在加载的键名称的RedisModuleString。 无法保证键名称始终可用，因此可能会返回NULL。
RedisModule_GetKeyNameFromModuleKey
const RedisModuleString *RedisModule_GetKeyNameFromModuleKey(RedisModuleKey *key);返回带有RedisModuleKey的键名的RedisModuleString
RedisModule_LogRaw
void RedisModule_LogRaw(RedisModule *module, const char *levelstr, const char *fmt, va_list ap);这是实现以下两个功能的底层函数：
RM_Log()
RM_LogIOError()RedisModule_Log
void RedisModule_Log(RedisModuleCtx *ctx, const char *levelstr, const char *fmt, ...);生成标准Redis日志的日志消息，格式接受与printf相似的说明符，而level是描述发出日志时要使用的日志级别的字符串，并且必须为以下之一：
- "debug"
- "verbose"
- "notice"
- "warning"
如果指定的日志级别无效，则默认情况下使用详细信息。 此函数能够发出的日志行的长度有一个固定的限制，没有指定此限制，但可以保证该限制不会超过几行文本。
如果无法在实例线程或回调的调用者上下文中提供ctx参数，则该参数可以为NULL，在这种情况下，将使用通用的“module”代替模块名称。
RedisModule_LogIOError
void RedisModule_LogIOError(RedisModuleIO *io, const char *levelstr, const char *fmt, ...);记录来自RDB / AOF序列化回调的错误。
当回调将严重错误返回给调用方时，应使用此函数，因为由于某些严重原因而无法加载或保存数据。
RedisModule__Assert
void RedisModule__Assert(const char *estr, const char *file, int line);类似于Redis的断言函数。
断言失败将关闭服务器并生成与Redis本身生成的信息相同的日志记录信息。
RedisModule_LatencyAddSample
void RedisModule_LatencyAddSample(const char *event, mstime_t latency);允许通过LATENCY命令观察到向延迟监视器添加事件。 如果等待时间小于配置的等待时间监视器阈值，则跳过该呼叫。
RedisModule_BlockClient
RedisModuleBlockedClient *RedisModule_BlockClient(RedisModuleCtx *ctx, RedisModuleCmdFunc reply_callback, RedisModuleCmdFunc timeout_callback, void (*free_privdata)(RedisModuleCtx*,void*), long long timeout_ms);在阻塞命令的上下文中阻塞客户端，然后返回一个句柄，以便稍后通过调用RedisModule_UnblockClient()来解除阻塞客户端。 参数指定回调函数和超时，之后客户端将被解除阻止。
在以下上下文中调用回调：
reply_callback: called after a successful RedisModule_UnblockClient()
call in order to reply to the client and unblock it.
timeout_callback: called when the timeout is reached in order to send an
error to the client.
free_privdata: called in order to free the private data that is passed
by RedisModule_UnblockClient() call.注意：应该为每个被阻止的客户端调用RedisModule_UnblockClient，即使客户端被杀死，超时或断开连接也是如此。 否则，将导致内存泄漏。
在某些情况下，不能使用RedisModule_BlockClient()：
- 如果客户端是Lua脚本。
- 如果客户端正在执行MULTI块。
在这些情况下，对RedisModule_BlockClient()的调用不会阻止客户端，而是会产生特定的错误回复。
RedisModule_BlockClientOnKeys
RedisModuleBlockedClient *RedisModule_BlockClientOnKeys(RedisModuleCtx *ctx, RedisModuleCmdFunc reply_callback, RedisModuleCmdFunc timeout_callback, void (*free_privdata)(RedisModuleCtx*,void*), long long timeout_ms, RedisModuleString **keys, int numkeys, void *privdata);此调用类似于RedisModule_BlockClient()，但是在这种情况下，我们不仅阻止了客户端，而且还要求Redis在某些键“准备就绪”（即包含更多数据）后自动解除对客户端的阻止。
基本上，这类似于典型的Redis命令通常执行的操作，例如BLPOP或BZPOPMAX：如果无法尽快为客户端提供服务，则客户端将阻止，然后，当密钥接收到新数据（例如，列表推送）时，客户端将被取消阻止并提供服务 。
但是，在使用此模块API的情况下，何时解除阻止客户端？
- 如果你阻止某个具有关联的阻止操作的类型的键（例如列表，排序集，流等），则一旦相关键被正常取消阻止本机阻止的操作作为目标，则可以取消阻止客户端 该类型的操作。 因此，如果我们阻止列表键，则RPUSH命令可能会取消阻止我们的客户端，依此类推。
- 如果要实现本机数据类型，或者除“ 1”之外还要添加新的解锁条件，则可以调用模块API RedisModule_SignalKeyAsReady()。
无论如何，我们不能仅仅因为密钥已准备好就确定是否应该解除客户端的阻塞：例如，连续的操作可能会更改密钥，或者在队列中的一个客户端可以提供服务之前，还要修改键，并且 再次将其清空。 因此，当使用RedisModule_BlockClientOnKeys()阻止客户端时，在调用RM_UnblockCLient()之后不会调用回复回调，但是每次信号提示就绪时：如果回复回调可以为客户端提供服务，它将返回REDISMODULE_OK并且客户端被取消阻止 ，否则它将返回REDISMODULE_ERR，我们稍后将重试。
回复回调可以通过调用API RedisModule_GetBlockedClientReadyKey()来访问表示已准备就绪的密钥，该API仅将密钥的字符串名称作为RedisModuleString对象返回。
借助此系统，我们可以设置复杂的阻止方案，例如仅在列表包含至少5个项目或其他更特别的逻辑时才解除对客户端的阻止。
请注意，与RedisModule_BlockClient()的另一个区别是，这里我们在阻止客户端时直接传递私有数据：稍后将在回复回调中访问它。通常，在使用RedisModule_BlockClient()进行阻止时，调用RedisModule_UnblockClient()时会传递要回复客户端的私有数据，但此处的解除阻止是由Redis本身执行的，因此我们需要事先拥有一些私有数据。私有数据用于存储有关你正在实施的特定解锁操作的任何信息。此类信息将使用用户提供的free_privdata回调释放。
但是，回复回调将能够访问命令的参数向量，因此通常不需要私有数据。
注意：在正常情况下，不应为在键上被阻止的客户端调用RedisModule_UnblockClient（要么键准备就绪，要么发生超时）。如果出于某些原因你确实想调用RedisModule_UnblockClient，则可以：客户端将被视为超时（在这种情况下，你必须实现超时回调）。
RedisModule_SignalKeyAsReady
void RedisModule_SignalKeyAsReady(RedisModuleCtx *ctx, RedisModuleString *key);使用此函数是为了可能解除对RedisModule_BlockClientOnKeys()的键上被阻止的客户端的阻止。 调用此函数时，为此键阻塞的所有客户端都将被调用其Reply_callback。
注意：如果信号键不存在，则该功能无效。
RedisModule_UnblockClient
int RedisModule_UnblockClient(RedisModuleBlockedClient *bc, void *privdata);解除阻止由RedisModule_BlockedClient阻止的客户端。这将触发调用回复回调以回复客户端。回复回调可以访问'privdata'参数，因此此函数的调用者可以传递任何要实际回复客户端所需的值。
“privdata”的常见用法是一个线程，该线程计算需要传递给客户端的内容，包括但不限于计算速度较慢或通过网络获得的某些响应。
注意1：可以从模块产生的线程中调用此函数。
注意2：当我们使用API RedisModule_BlockClientOnKeys()取消阻止被密钥阻止的客户端时，此处不使用privdata参数。取消阻止使用此API阻止了键的客户端仍将要求客户端获得一些回复，因此该函数将使用“超时”处理程序来这样做（可通过超时回调访问RedisModule_BlockClientOnKeys()中提供的privdata通过RM_GetBlockedClientPrivateData）。
RedisModule_AbortBlock
int RedisModule_AbortBlock(RedisModuleBlockedClient *bc);中止被阻止的客户端阻止操作：客户端将被取消阻止而不会触发任何回调。
RedisModule_SetDisconnectCallback
void RedisModule_SetDisconnectCallback(RedisModuleBlockedClient *bc, RedisModuleDisconnectFunc callback);设置在模块有机会调用RedisModule_UnblockClient（）之前被阻止的客户端断开连接时将调用的回调
通常，你要在此处执行的操作是清除模块状态，以便可以安全地调用RedisModule_UnblockClient（），否则，如果超时很大，客户端将永远保持阻塞状态。
笔记：
- 在这里调用Reply *系列功能并不安全，因为客户端已消失，这也是没有用的。
- 如果客户端由于超时而断开连接，则不会调用此回调。 在这种情况下，客户端将自动解除阻塞并调用超时回调。
RedisModule_IsBlockedReplyRequest
int RedisModule_IsBlockedReplyRequest(RedisModuleCtx *ctx);如果调用模块命令以填充被阻止客户端的回复，则返回非零值。
RedisModule_IsBlockedTimeoutRequest
int RedisModule_IsBlockedTimeoutRequest(RedisModuleCtx *ctx);如果调用了模块命令以填充对超时的阻塞客户端的回复，则返回非零值。
RedisModule_GetBlockedClientPrivateData
void *RedisModule_GetBlockedClientPrivateData(RedisModuleCtx *ctx);通过RedisModule_UnblockClient()获取私有数据集
RedisModule_GetBlockedClientReadyKey
RedisModuleString *RedisModule_GetBlockedClientReadyKey(RedisModuleCtx *ctx);获取在RedisModule_BlockClientOnKeys()阻止的客户端上下文中调用回复回调时准备好的键。
RedisModule_GetBlockedClientHandle
RedisModuleBlockedClient *RedisModule_GetBlockedClientHandle(RedisModuleCtx *ctx);获取与给定上下文关联的被阻止的客户端。 在模块被阻止的客户端句柄到处并希望清除之前，这在阻止的客户端的回复和超时回调中很有用。
RedisModule_BlockedClientDisconnected
int RedisModule_BlockedClientDisconnected(RedisModuleCtx *ctx);如果调用被阻止客户端的免费回调时返回true，则取消阻止该客户端的原因是该客户端在被阻止时已断开连接。
RedisModule_GetThreadSafeContext
RedisModuleCtx *RedisModule_GetThreadSafeContext(RedisModuleBlockedClient *bc);返回一个上下文，该上下文可在线程内部使用，以使用某些模块API进行Redis上下文调用。 如果'bc'不为NULL，则模块将绑定到被阻止的客户端，并且可以使用`RedisModule_Reply *`函数族来积累对客户端何时被解除阻止的回复。 否则，线程安全上下文将由特定客户端分离。
要调用非回复API，必须使用以下内容准备线程安全上下文：
RedisModule_ThreadSafeContextLock(ctx);
... make your call here ...
RedisModule_ThreadSafeContextUnlock(ctx);当使用`RedisModule_Replyfunctions'时，这是不需要的，假设在创建上下文时使用了被阻止的客户端，否则应该完全不进行noRedisModule_Reply`调用。
注意：如果要创建分离的线程安全上下文（bc为NULL），请考虑使用RM_GetDetachedThreadSafeContext，它还将保留模块ID，因此对于日志记录更加有用。
RedisModule_GetDetachedThreadSafeContext
RedisModuleCtx *RedisModule_GetDetachedThreadSafeContext(RedisModuleCtx *ctx);返回一个与任何特定的被阻止的客户端不相关但与模块的上下文相关联的分离线程安全上下文。
这对于希望长期保存全局上下文的模块很有用，例如日志记录。
RedisModule_FreeThreadSafeContext
void RedisModule_FreeThreadSafeContext(RedisModuleCtx *ctx);释放线程安全上下文。
RedisModule_ThreadSafeContextLock
void RedisModule_ThreadSafeContextLock(RedisModuleCtx *ctx);在执行线程安全的API调用之前，请获取服务器锁。 当有阻塞的客户端连接到线程安全上下文时，`RedisModule_Reply *`调用不需要此操作。
RedisModule_ThreadSafeContextTryLock
int RedisModule_ThreadSafeContextTryLock(RedisModuleCtx *ctx);与RM_ThreadSafeContextLock相似，但是如果已经获得服务器锁，则此功能不会阻塞。
如果成功（获得锁），则返回REDISMODULE_OK，否则返回REDISMODULE_ERR并相应地设置errno。
RedisModule_ThreadSafeContextUnlock
void RedisModule_ThreadSafeContextUnlock(RedisModuleCtx *ctx);执行线程安全的API调用后，释放服务器锁。
RedisModule_SubscribeToKeyspaceEvents
int RedisModule_SubscribeToKeyspaceEvents(RedisModuleCtx *ctx, int types, RedisModuleNotificationFunc callback);订阅键空间通知。 这是keyspace-notifications API的低级版本。 模块可以注册回调，以便在键空间事件发生时得到通知。
通知事件按其类型（字符串事件，设置事件等）进行过滤，并且订阅者回调仅接收与特定事件类型掩码匹配的事件。
使用RedisModule_SubscribeToKeyspaceEvents订阅通知时，模块必须提供事件类型掩码，表示订阅者感兴趣的事件。这可以是以下任意标志的ORed掩码：
- REDISMODULENOTIFYGENERIC: 通用命令，例如DEL，EXPIRE，RENAME
- REDISMODULENOTIFYSTRING: String events
- REDISMODULENOTIFYLIST: List events
- REDISMODULENOTIFYSET: Set events
- REDISMODULENOTIFYHASH: Hash events
- REDISMODULENOTIFYZSET: Sorted Set events
- REDISMODULENOTIFYEXPIRED: Expiration events
- REDISMODULENOTIFYEVICTED: Eviction events
- REDISMODULENOTIFYSTREAM: Stream events
- REDISMODULENOTIFYKEYMISS: Key-miss events
- REDISMODULENOTIFYALL: All events (Excluding REDISMODULENOTIFYKEYMISS)
- REDISMODULENOTIFYLOADED: 仅适用于模块的特殊通知表示该键是从持久性加载的。 请注意，在触发此事件时，无法保留给定的键，请改用RM_CreateStringFromString。
我们不区分键事件和键空间事件，而是由模块来过滤基于键采取的操作。
subscriber签名是：
int (*RedisModuleNotificationFunc) (RedisModuleCtx *ctx, int type, const char *event, RedisModuleString *key);
type是事件类型位，必须与注册时指定的掩码匹配。 事件字符串是正在执行的实际命令，而key是相关的Redis键。
通知回调使用redis上下文执行，该上下文不能用于将任何内容发送到客户端，并且具有发生事件的db编号作为其选定的db编号。
请注意，不必在redis.conf中启用通知即可使模块通知正常工作。
警告：通知回调是以同步方式执行的，因此通知回调必须快速，否则会降低Redis的速度。 如果需要采取长时间的操作，请使用线程来减轻它们的负担。
有关更多信息，请参见https://redis.io/topics/notifications。
RedisModule_GetNotifyKeyspaceEvents
int RedisModule_GetNotifyKeyspaceEvents();获取已配置的notify-keyspace-events位图（可用于RedisModuleNotificationFunc中的其他过滤）
RedisModule_NotifyKeyspaceEvent
int RedisModule_NotifyKeyspaceEvent(RedisModuleCtx *ctx, int type, const char *event, RedisModuleString *key);将notifyKeyspaceEvent公开给模块
RedisModule_RegisterClusterMessageReceiver
void RedisModule_RegisterClusterMessageReceiver(RedisModuleCtx *ctx, uint8_t type, RedisModuleClusterMessageReceiver callback);为类型为“type”的集群消息注册回调接收器。 如果已经有一个注册的回调，它将用提供的回调替换该回调函数，否则，如果将该回调设置为NULL并且该函数已经有一个回调，则该回调未注册（因此该API调用也用于以删除接收方）。
RedisModule_SendClusterMessage
int RedisModule_SendClusterMessage(RedisModuleCtx *ctx, char *target_id, uint8_t type, unsigned char *msg, uint32_t len);如果目标为NULL，则向集群中的所有节点发送消息，否则，向指定目标发送消息，该目标是REDISMODULE_NODE_ID_LEN字节的节点ID，由接收者回调或节点迭代函数返回。
如果成功发送了消息，该函数将返回REDISMODULE_OK，否则，如果该节点未连接或该节点ID未映射到任何已知的群集节点，则返回REDISMODULE_ERR。
RedisModule_GetClusterNodesList
char **RedisModule_GetClusterNodesList(RedisModuleCtx *ctx, size_t *numnodes);返回一个字符串指针数组，每个字符串指针指向正好为REDISMODULE_NODE_ID_SIZE字节的群集节点ID（不包含任何空项）。 返回的节点ID的数量存储在* numnodes中。 但是，如果未运行启用Redis群集的Redis实例的模块调用此函数，则会返回NULL。
返回的ID可以与RedisModule_GetClusterNodeInfo()一起使用，以获取有关单个节点的更多信息。
必须使用函数RedisModule_FreeClusterNodesList()释放此函数返回的数组。
例：
size_t count, j;
char **ids = RedisModule_GetClusterNodesList(ctx,&count);
for (j = 0; j < count; j++) {
RedisModule_Log("notice","Node %.*s",
REDISMODULE_NODE_ID_LEN,ids[j]);
}
RedisModule_FreeClusterNodesList(ids);RedisModule_FreeClusterNodesList
void RedisModule_FreeClusterNodesList(char **ids);释放通过RedisModule_GetClusterNodesList获得的节点列表。
RedisModule_GetMyClusterID
const char *RedisModule_GetMyClusterID(void);返回此节点ID（REDISMODULE_CLUSTER_ID_LEN字节），如果禁用了集群，则返回NULL。
RedisModule_GetClusterSize
size_t RedisModule_GetClusterSize(void);返回群集中节点的数量，而不管它们的状态如何（handshake, noaddress, ...），以便活动节点的数量实际上可以较小，但不大于此数量。 如果实例不在群集模式下，则返回零。
RedisModule_SetClusterFlags
void RedisModule_SetClusterFlags(RedisModuleCtx *ctx, uint64_t flags);设置Redis Cluster标志以更改Redis Cluster的正常行为，尤其是为了禁用某些功能。 这对于使用Cluster API来创建其他分布式系统但仍要使用Redis Cluster消息总线的模块很有用。 可以设置的标志：
集群模块化ULAFAILOVER集群模块化ULANO重定向
具有以下效果：
NO_FAILOVER：防止Redis Cluster从属设备对发生故障的主节点进行故障转移。 同时禁用副本迁移功能。
NO_REDIRECTION：每个节点将接受任何密钥，而不会尝试根据用户Redis Cluster算法执行分区。 插槽信息仍将在整个群集中传播，但不会产生影响。
RedisModule_CreateTimer
RedisModuleTimerID RedisModule_CreateTimer(RedisModuleCtx *ctx, mstime_t period, RedisModuleTimerProc callback, void *data);创建一个新的计时器，该计时器将在周期毫秒后触发，并将使用data作为参数调用指定的函数。 返回的计时器ID可用于从计时器获取信息或在启动前停止计时器。
RedisModule_StopTimer
int RedisModule_StopTimer(RedisModuleCtx *ctx, RedisModuleTimerID id, void **data);停止计时器，如果找到该计时器，属于调用模块并且已停止，则返回REDISMODULE_OK，否则返回REDISMODULE_ERR。 如果不为NULL，则在创建计时器时，数据指针将设置为data参数的值。
RedisModule_GetTimerInfo
int RedisModule_GetTimerInfo(RedisModuleCtx *ctx, RedisModuleTimerID id, uint64_t *remaining, void **data);获取有关计时器的信息：触发前的剩余时间（以毫秒为单位），以及与计时器关联的专用数据指针。 如果指定的计时器不存在或不属于其他模块，则不返回任何信息，该函数返回REDISMODULE_ERR，否则返回REDISMODULE_OK。 如果调用方不需要某些信息，则剩余参数或数据可以为NULL。
RedisModule_CreateModuleUser
RedisModuleUser *RedisModule_CreateModuleUser(const char *name);创建模块可用于认证客户端的Redis ACL用户。 获取用户后，模块应使用RM_SetUserACL()函数设置该用户可以执行的操作。 配置完成后，可以使用用户使用RedisModule_AuthClientWithUser()函数使用指定的ACL规则对连接进行身份验证。
注意：
- ACL命令未列出此处创建的用户。
- 不会检查此处创建的用户的名称是否重复，因此由调用此函数的模块负责不要创建具有相同名称的用户。
- 创建的用户可用于认证多个Redis连接。
调用者以后可以使用函数RM_FreeModuleUser()释放用户。 调用此函数时，如果仍然有与此用户进行身份验证的客户端，它们将被断开连接。 仅当调用者真的想使用户无效以定义具有不同功能的新用户时，才应使用释放用户的功能。
RedisModule_FreeModuleUser
int RedisModule_FreeModuleUser(RedisModuleUser *user);释放给定的用户，并断开所有已通过该用户验证的客户端。 有关详细用法，请参见RM_CreateModuleUser。
RedisModule_SetModuleUserACL
int RedisModule_SetModuleUserACL(RedisModuleUser *user, const char* acl);设置通过redis模块界面创建的用户的权限。 语法与ACL SETUSER相同，因此请参阅acl.c中的文档以获取更多信息。 有关详细用法，请参见RM_CreateModuleUser。
如果成功则返回REDISMODULE_OK，如果失败则返回REDISMODULE_ERR，并将设置一个错误号，以描述操作失败的原因。
RedisModule_AuthenticateClientWithUser
int RedisModule_AuthenticateClientWithUser(RedisModuleCtx *ctx, RedisModuleUser *module_user, RedisModuleUserChangedFunc callback, void *privdata, uint64_t *client_id);使用提供的redis acl用户对当前上下文的用户进行身份验证。 如果禁用了用户，则返回REDISMODULE_ERR。
有关身份验证的回调，client_id和常规用法的信息，请参见authenticateClientWithUser。
RedisModule_AuthenticateClientWithACLUser
int RedisModule_AuthenticateClientWithACLUser(RedisModuleCtx *ctx, const char *name, size_t len, RedisModuleUserChangedFunc callback, void *privdata, uint64_t *client_id);使用提供的redis acl用户对当前上下文的用户进行身份验证。 如果禁用了该用户或该用户不存在，则返回REDISMODULE_ERR。
有关身份验证的回调，client_id和常规用法的信息，请参见authenticateClientWithUser。
RedisModule_DeauthenticateAndCloseClient
int RedisModule_DeauthenticateAndCloseClient(RedisModuleCtx *ctx, uint64_t client_id);取消认证并关闭客户端。 客户端资源将不会立即释放，但会在后台作业中清理。 由于大多数客户端都无法处理取消身份验证的用户，因此建议你取消对客户端的身份验证。 如果客户端不存在，则返回REDISMODULE_ERR；如果操作成功，则返回REDISMODULE_OK。
客户端ID是从RM_AuthenticateClientWithUser和RM_AuthenticateClientWithACLUser API返回的，但可以通过CLIENT api或通过服务器事件获取。
此函数不是线程安全的，必须在命令或线程安全上下文中执行。
RedisModule_GetClientCertificate
RedisModuleString *RedisModule_GetClientCertificate(RedisModuleCtx *ctx, uint64_t client_id);返回客户端用来验证此连接的X.509客户端证书。
返回值是分配的RedisModuleString，它是以PEM（Base64）格式编码的X.509证书。 调用者应将其释放（或自动释放）。
在以下情况下返回NULL值：
- 连接ID不存在
- 连接不是TLS连接
- 连接是TLS连接，但未使用客户端证书
RedisModule_CreateDict
RedisModuleDict *RedisModule_CreateDict(RedisModuleCtx *ctx);创建一个新的字典。 'ctx'指针可以是当前模块的上下文，也可以是NULL，具体取决于你想要的内容。 请遵守以下规则：
- 如果你打算保留对此字典的引用，请使用NULL上下文，该引用将在创建该字典的模块回调期间继续存在。
- 如果在创建字典时没有上下文可用，请使用NULL上下文（当然...）。
- 但是，如果字典的生存时间仅限于回调范围，则将当前回调上下文用作“ctx”参数。 在这种情况下，如果启用了该功能，则可以享受自动内存管理功能，它将回收字典内存以及Next / Prev字典迭代器调用返回的字符串。
RedisModule_FreeDict
void RedisModule_FreeDict(RedisModuleCtx *ctx, RedisModuleDict *d);释放使用RM_CreateDict()创建的字典。 仅当使用上下文创建字典时才需要传递上下文指针“ctx”，而不是传递NULL。
RedisModule_DictSize
uint64_t RedisModule_DictSize(RedisModuleDict *d);返回字典的大小（键数）。
RedisModule_DictSetC
int RedisModule_DictSetC(RedisModuleDict *d, void *key, size_t keylen, void *ptr);将指定的键存储到字典中，并将其值设置为指针“ptr”。 如果成功添加了密钥，因为它尚不存在，则返回REDISMODULE_OK。 否则，如果键已经存在，则函数返回REDISMODULE_ERR。
RedisModule_DictReplaceC
int RedisModule_DictReplaceC(RedisModuleDict *d, void *key, size_t keylen, void *ptr);与RedisModule_DictSetC()类似，但是如果键已经存在，则将其替换为新值。
RedisModule_DictSet
int RedisModule_DictSet(RedisModuleDict *d, RedisModuleString *key, void *ptr);与RedisModule_DictSetC()类似，但是将键作为RedisModuleString。
RedisModule_DictReplace
int RedisModule_DictReplace(RedisModuleDict *d, RedisModuleString *key, void *ptr);与RedisModule_DictReplaceC()类似，但是将键作为RedisModuleString。
RedisModule_DictGetC
void *RedisModule_DictGetC(RedisModuleDict *d, void *key, size_t keylen, int *nokey);返回存储在指定键上的值。 在键不存在的情况下，或者在键处实际存储NULL的情况下，该函数均返回NULL。 因此，可选地，如果“nokey”指针不为NULL，则在不存在键的情况下通过引用将其设置为1，在存在键的情况下通过引用将其设置为0。
RedisModule_DictGet
void *RedisModule_DictGet(RedisModuleDict *d, RedisModuleString *key, int *nokey);与RedisModule_DictGetC()类似，但将键作为RedisModuleString。
RedisModule_DictDelC
int RedisModule_DictDelC(RedisModuleDict *d, void *key, size_t keylen, void *oldval);从字典中删除指定的键，如果找到并删除了该键，则返回REDISMODULE_OK；如果字典中没有该键，则返回REDISMODULE_ERR。 操作成功后，如果'oldval'不为NULL，则'* oldval'设置为删除之前存储在键上的值。 使用此功能，可以获取指向该值的指针（例如为了释放它），而无需在删除键之前调用RedisModule_DictGet()。
RedisModule_DictDel
int RedisModule_DictDel(RedisModuleDict *d, RedisModuleString *key, void *oldval);像RedisModule_DictDelC()一样，但是以RedisModuleString的形式获取密钥。
RedisModule_DictIteratorStartC
RedisModuleDictIter *RedisModule_DictIteratorStartC(RedisModuleDict *d, const char *op, void *key, size_t keylen);返回一个迭代器，设置该序列以便通过应用运算符'op'从指定的键开始迭代，该运算符只是一个字符串，指定用于查找第一个元素的比较运算符。 可用的运算符为：
- "" -- 寻求第一个（按字典顺序较小的）键.
- "$" -- 寻求最后一个（按字典顺序）。
- ">" -- 寻求大于指定键的第一个元素。
- ">=" -- 寻求大于或等于指定键的第一个元素。
- "<" -- 寻找小于指定键的第一个元素。
- "<=" -- 寻求小于或等于指定键的第一个元素。
- "==" -- 寻求与指定键完全匹配的第一个元素。
请注意，对于""和"$"，不使用传递的键，用户可以仅传递长度为0的NULL。
如果无法根据传递的键和运算符来查找开始迭代的元素，则RedisModule_DictNext()/ Prev()只会在第一次调用时返回REDISMODULE_ERR，否则它们将生成元素。
RedisModule_DictIteratorStart
RedisModuleDictIter *RedisModule_DictIteratorStart(RedisModuleDict *d, const char *op, RedisModuleString *key);与RedisModule_DictIteratorStartC完全一样，但是密钥作为RedisModuleString传递。
RedisModule_DictIteratorStop
void RedisModule_DictIteratorStop(RedisModuleDictIter *di);释放使用RedisModule_DictIteratorStart()创建的迭代器。 该调用是强制性的，否则模块中会引入内存泄漏。
RedisModule_DictIteratorReseekC
int RedisModule_DictIteratorReseekC(RedisModuleDictIter *di, const char *op, void *key, size_t keylen);使用RedisModule_DictIteratorStart()创建之后，可以使用此API调用更改迭代器的当前选定元素。 基于运算符和键的结果与RedisModule_DictIteratorStart()函数完全相同，但是在这种情况下，如果找到了要查找的元素，则返回值仅为REDISMODULE_OK；如果无法找到指定的元素，则返回值为REDISMODULE_ERR。你可以根据需要重新搜索迭代器多次。
RedisModule_DictIteratorReseek
int RedisModule_DictIteratorReseek(RedisModuleDictIter *di, const char *op, RedisModuleString *key);像RedisModule_DictIteratorReseekC()一样，但是将密钥作为RedisModuleString使用。
RedisModule_DictNextC
void *RedisModule_DictNextC(RedisModuleDictIter *di, size_t *keylen, void **dataptr);返回字典迭代器“di”的当前项目，并移至下一个元素。 如果迭代器已经产生了最后一个元素，并且没有其他要返回的元素，则返回NULL，否则提供指向表示键的字符串的指针，并通过引用设置“keylen”的长度（如果keylen不为NULL） 。 如果不为NULL，则将'dataptr'设置为作为辅助数据存储在返回键处的指针的值（由RedisModule_DictSet API设置）。
... create the iterator here ...
char *key;
void *data;
while((key = RedisModule_DictNextC(iter,&keylen,&data)) != NULL) {
printf("%.*s %p\n", (int)keylen, key, data);
}返回的指针的类型为void，因为有时根据它包含或不包含二进制数据的事实将其强制转换为char *有时转换为无符号char *是有意义的，因此该API使用起来更加舒适。
返回的指针的有效性一直到next/prev迭代器步骤的下一次调用为止。 同样，一旦释放迭代器，指针将不再有效。
RedisModule_DictPrevC
void *RedisModule_DictPrevC(RedisModuleDictIter *di, size_t *keylen, void **dataptr);该函数与RedisModule_DictNext()完全一样，但是在返回迭代器中当前选定的元素之后，它将选择上一个元素（在逻辑上较小），而不是下一个。
RedisModule_DictNext
RedisModuleString *RedisModule_DictNext(RedisModuleCtx *ctx, RedisModuleDictIter *di, void **dataptr);与RedisModuleNextC()一样，但是它不返回内部分配的缓冲区和键长，而是直接返回在指定上下文“ctx”中分配的模块字符串对象（与主要API RedisModule_CreateString完全相同，它可能为NULL）。
返回的字符串对象应在使用后手动或使用具有自动内存管理功能的上下文重新分配。
RedisModule_DictPrev
RedisModuleString *RedisModule_DictPrev(RedisModuleCtx *ctx, RedisModuleDictIter *di, void **dataptr);与RedisModule_DictNext()类似，但是在返回迭代器中当前选定的元素之后，它将选择上一个元素（在逻辑上较小），而不是下一个。
RedisModule_DictCompareC
int RedisModule_DictCompareC(RedisModuleDictIter *di, const char *op, void *key, size_t keylen);根据运算符“op”，将迭代器当前指向的元素与key / keylen给定的指定元素进行比较（有效运算符的集合对于RedisModule_DictIteratorStart而言是相同的）。 如果比较成功，则命令返回REDISMODULE_OK，否则返回REDISMODULE_ERR。
当我们只想发出字典范围时，这很有用，因此在循环中，当我们迭代元素时，我们还可以检查我们是否仍在范围内。
如果迭代器也达到元素结尾条件，则该函数返回REDISMODULE_ERR。
RedisModule_DictCompare
int RedisModule_DictCompare(RedisModuleDictIter *di, const char *op, RedisModuleString *key);像RedisModule_DictCompareC一样，但是以RedisModuleString的形式获取与当前迭代器密钥进行比较的键。
RedisModule_InfoAddSection
int RedisModule_InfoAddSection(RedisModuleInfoCtx *ctx, char *name);用于在添加任何字段之前开始新的部分。 该部分的名称将以“_”作为前缀，并且只能包含A-Z，a-z，0-9。 NULL或空字符串表示使用默认部分（仅）。 当返回值为REDISMODULE_ERR时，应且将跳过该部分。
RedisModule_InfoBeginDictField
int RedisModule_InfoBeginDictField(RedisModuleInfoCtx *ctx, char *name);启动一个dict字段，类似于INFO KEYSPACE中的字段。 使用常规的RedisModule_InfoAddField *函数将项目添加到此字段，并以RedisModule_InfoEndDictField终止。
RedisModule_InfoEndDictField
int RedisModule_InfoEndDictField(RedisModuleInfoCtx *ctx);结束一个dict字段，请参见RedisModule_InfoBeginDictField
RedisModule_InfoAddFieldString
int RedisModule_InfoAddFieldString(RedisModuleInfoCtx *ctx, char *field, RedisModuleString *value);由RedisModuleInfoFunc用于添加信息字段。 每个字段将自动以“_”作为前缀。 字段名称或值不得包含“:”的 \r\n
RedisModule_GetServerInfo
RedisModuleServerInfoData *RedisModule_GetServerInfo(RedisModuleCtx *ctx, const char *section);获取有关服务器的信息，类似于从INFO命令返回的信息。 该函数采用可选的“section”参数，该参数可以为NULL。 返回值保存输出，可以与RedisModule_ServerInfoGetField一起使用，以类似方式获取各个字段。 完成后，需要使用RedisModule_FreeServerInfo或自动内存管理机制（如果启用）释放它。
RedisModule_FreeServerInfo
void RedisModule_FreeServerInfo(RedisModuleCtx *ctx, RedisModuleServerInfoData *data);用RM_GetServerInfo()创建的免费数据。 仅当使用上下文创建字典时才需要传递上下文指针“ctx”，而不是传递NULL。
RedisModule_ServerInfoGetField
RedisModuleString *RedisModule_ServerInfoGetField(RedisModuleCtx *ctx, RedisModuleServerInfoData *data, const char* field);从使用RM_GetServerInfo()收集的数据中获取字段的值。 仅当你要使用自动存储机制释放返回的字符串时，才需要传递上下文指针“ctx”。 如果找不到该字段，则返回值为NULL。
RedisModule_ServerInfoGetFieldC
const char *RedisModule_ServerInfoGetFieldC(RedisModuleServerInfoData *data, const char* field);与RM_ServerInfoGetField相似，但返回一个char *，不应将其释放，而是调用者。
RedisModule_ServerInfoGetFieldSigned
long long RedisModule_ServerInfoGetFieldSigned(RedisModuleServerInfoData *data, const char* field, int *out_err);从使用RM_GetServerInfo()收集的数据中获取字段的值。 如果未找到该字段，或者该字段不是数字或超出范围，则返回值将为0，并且可选的out_err参数将设置为REDISMODULE_ERR。
RedisModule_ServerInfoGetFieldUnsigned
unsigned long long RedisModule_ServerInfoGetFieldUnsigned(RedisModuleServerInfoData *data, const char* field, int *out_err);从使用RM_GetServerInfo()收集的数据中获取字段的值。 如果未找到该字段，或者该字段不是数字或超出范围，则返回值将为0，并且可选的out_err参数将设置为REDISMODULE_ERR。
RedisModule_ServerInfoGetFieldDouble
double RedisModule_ServerInfoGetFieldDouble(RedisModuleServerInfoData *data, const char* field, int *out_err);从使用RM_GetServerInfo()收集的数据中获取字段的值。 如果未找到该字段或该字段不是双精度型，则返回值为0，并且可选的out_err参数将设置为REDISMODULE_ERR。
RedisModule_GetRandomBytes
void RedisModule_GetRandomBytes(unsigned char *dst, size_t len);在计数器模式下使用SHA1返回带有/dev/urandom初始化种子的随机字节。 此函数速度很快，因此可用于生成许多字节，而对操作系统熵池没有任何影响。 当前，此函数不是线程安全的。
RedisModule_GetRandomHexChars
void RedisModule_GetRandomHexChars(char *dst, size_t len);与RedisModule_GetRandomBytes()类似，但不是将字符串设置为随机字节，而是在十六进制字符集[0-9a-f]中将字符串设置为随机字符。
RedisModule_ExportSharedAPI
int RedisModule_ExportSharedAPI(RedisModuleCtx *ctx, const char *apiname, void *func);为了导出具有给定名称的某些API，模块会调用此函数。 其他模块将能够通过调用对称函数RM_GetSharedAPI()并将返回值强制转换为正确的函数指针来使用此API。
如果名称尚未使用，则该函数将返回REDISMODULE_OK，否则将返回REDISMODULE_ERR，并且将不执行任何操作。
重要说明：apiname参数应该是具有静态生存期的字符串文字。 API依赖于这样的事实，即将来它将始终有效。
RedisModule_GetSharedAPI
void *RedisModule_GetSharedAPI(RedisModuleCtx *ctx, const char *apiname);请求导出的API指针。 返回值只是一个void指针，要求此函数的调用方将其强制转换为正确的函数指针，因此这是模块之间的私有协定。
如果请求的API不可用，则返回NULL。 由于模块可以在不同的时间以不同的顺序加载，因此此函数调用应放在某个模块通用API注册步骤中，该步骤在模块每次尝试执行需要外部API的命令时调用：如果某些API无法解析， 该命令应返回错误。
这是一个例子：
int ... myCommandImplementation() {
if (getExternalAPIs() == 0) {
reply with an error here if we cannot have the APIs
}
// Use the API:
myFunctionPointer(foo);
}函数registerAPI()是：
int getExternalAPIs(void) {
static int api_loaded = 0;
if (api_loaded != 0) return 1; // APIs already resolved.
myFunctionPointer = RedisModule_GetOtherModuleAPI("...");
if (myFunctionPointer == NULL) return 0;
return 1;
}RedisModule_UnregisterCommandFilter
int RedisModule_UnregisterCommandFilter(RedisModuleCtx *ctx, RedisModuleCommandFilter *filter);取消注册命令过滤器。
RedisModule_CommandFilterArgsCount
int RedisModule_CommandFilterArgsCount(RedisModuleCommandFilterCtx *fctx);返回过滤的命令具有的参数数量。 参数的数量包括命令本身。
RedisModule_CommandFilterArgGet
const RedisModuleString *RedisModule_CommandFilterArgGet(RedisModuleCommandFilterCtx *fctx, int pos);返回指定的命令参数。 第一个参数（位置0）是命令本身，其余参数是用户提供的参数。
RedisModule_CommandFilterArgDelete
int RedisModule_CommandFilterArgDelete(RedisModuleCommandFilterCtx *fctx, int pos);通过删除指定位置的参数来修改过滤的命令。
RedisModule_MallocSize
size_t RedisModule_MallocSize(void* ptr);对于通过RedisModule_Alloc()或RedisModule_Realloc()分配的给定指针，返回为其分配的内存量。 请注意，这可能与我们通过分配调用分配的内存不同（更大），因为有时基础分配器会分配更多的内存。
RedisModule_GetUsedMemoryRatio
float RedisModule_GetUsedMemoryRatio();返回0到1之间的数字，表示相对于Redis“maxmemory”配置的当前使用的内存量。
0-未配置内存限制。 0到1之间-所使用的内存百分比在0-1范围内归一化。 恰好1-达到内存限制。 大于1-使用的内存超过配置的限制。
RedisModule_ScanCursorCreate
RedisModuleScanCursor *RedisModule_ScanCursorCreate();创建一个要与RedisModule_Scan一起使用的新光标
RedisModule_ScanCursorRestart
void RedisModule_ScanCursorRestart(RedisModuleScanCursor *cursor);重新启动现有的游标。 密钥将被重新扫描。
RedisModule_ScanCursorDestroy
void RedisModule_ScanCursorDestroy(RedisModuleScanCursor *cursor);销毁光标结构。
RedisModule_Scan
int RedisModule_Scan(RedisModuleCtx *ctx, RedisModuleScanCursor *cursor, RedisModuleScanCB fn, void *privdata);扫描API，允许模块扫描所选数据库中的所有键和值。
回调以执行扫描。 void scan_callback(RedisModuleCtx *ctx, RedisModuleString *keyname, RedisModuleKey *key, void *privdata); ctx-为扫描提供的redis模块上下文。 键名-由调用方拥有，如果在此函数后使用，则必须保留。
key-保留有关键和值的信息，它是尽力而为提供的，在某些情况下，它可能为NULL，在这种情况下，用户应（可以）使用RedisModule_OpenKey（以及CloseKey）。 提供时，它归调用者所有，并且在回调返回时将是自由的。
privdata-提供给RedisModule_Scan的用户数据。
应该使用的方式：RedisModuleCursor *c = RedisModuleScanCursorCreate(); while(RedisModuleScan(ctx, c, callback, privateData)); RedisModule_ScanCursorDestroy(c);
在实际调用RM_Scan期间获得锁的同时，也可以从另一个线程使用此API：
RedisModuleCursor *c = RedisModule_ScanCursorCreate();
RedisModule_ThreadSafeContextLock(ctx);
while(RedisModule_Scan(ctx, c, callback, privateData)){
RedisModule_ThreadSafeContextUnlock(ctx);
// do some background job
RedisModule_ThreadSafeContextLock(ctx);
}
RedisModule_ScanCursorDestroy(c);如果要扫描的元素更多，该函数将返回1，否则返回0，如果调用失败，则可能会设置errno。
也可以使用RM_ScanCursorRestart重新启动现有的游标。
重要说明：从提供保证的角度来看，此API与Redis SCAN命令非常相似。 这意味着API可以报告重复的密钥，但是可以保证从扫描过程的开始到结束，每个键至少报告一次。
注意：如果你在回调中进行数据库更改，则应注意数据库的内部状态可能会更改。 例如，删除或修改当前密钥是安全的，但是删除任何其他密钥可能并不安全。 此外，在迭代时使用Redis键空间可能会导致返回更多重复项。 一种安全的模式是将要修改的键名称存储在其他位置，并在迭代完成后稍后对键执行操作。 但是，这可能会占用大量内存，因此，只要这样做是安全的，就可以在迭代过程中尽可能在当前键上进行操作。
RedisModule_ScanKey
int RedisModule_ScanKey(RedisModuleKey *key, RedisModuleScanCursor *cursor, RedisModuleScanKeyCB fn, void *privdata);扫描API，允许模块扫描哈希，设置或排序的设置键中的元素
回调以执行扫描。 void scan_callback(RedisModuleKey key, RedisModuleString field, RedisModuleString* value, void *privdata); -key-为扫描提供的redis键上下文。 -field-字段名称，由调用者拥有，如果在此功能之后使用，则需要保留。 -值-设置类型的值字符串或NULL，由调用方拥有，如果在此函数之后使用，则需要保留。 -privdata-提供给RedisModule_ScanKey的用户数据。
应该使用的方式：
- RedisModuleCursor *c = RedisModuleScanCursorCreate();
- RedisModuleKey *key = RedisModuleOpenKey(...) while(RedisModuleScanKey(key, c, callback, privateData));
- RedisModuleCloseKey(key); RedisModule_ScanCursorDestroy(c);
在实际调用RM_ScanKey期间获取锁的同时，还可以从另一个线程使用此API，并每次都重新打开键：
- RedisModuleCursor *c = RedisModuleScanCursorCreate();
- RedisModuleThreadSafeContextLock(ctx);
- RedisModuleKey *key = RedisModuleOpenKey(...) while(RedisModuleScanKey(ctx, c, callback, privateData)){ RedisModuleCloseKey(key); RedisModuleThreadSafeContextUnlock(ctx); // do some background job RedisModuleThreadSafeContextLock(ctx);
- RedisModuleKey *key = RedisModuleOpenKey(...) }
- RedisModuleCloseKey(key); RedisModuleScanCursorDestroy(c);
如果要扫描的元素更多，该函数将返回1，否则返回0，如果调用失败，则可能会设置errno。 也可以使用RM_ScanCursorRestart重新启动现有的游标。
注意：迭代对象时某些操作是不安全的。 例如，尽管API保证从迭代的开始到结束至少一次返回数据结构中存在的所有元素（请参见HSCAN和类似的命令文档），但你使用这些元素的次数越多， 你可能会得到更多重复。 通常，删除数据结构的当前元素是安全的，而删除要迭代的密钥则不安全。
RedisModule_Fork
int RedisModule_Fork(RedisModuleForkDoneHandler cb, void *user_data);使用主进程的当前冻结快照主机创建一个后台子进程，你可以在其中在后台进行一些处理而不会影响/冻结流量，并且不需要线程和GIL锁定。 请注意，Redis仅允许一个并发派生。 当孩子想要退出时，应该调用RedisModule_ExitFromChild。 如果父级想要杀死该子级，则应调用RedisModule_KillForkChild当该子级存在时（而不是被杀死时）将在父级进程上执行完处理程序回调。返回：-1，失败时，父级进程将获得正PID 子进程，子进程将获得0。
RedisModule_ExitFromChild
int RedisModule_ExitFromChild(int retcode);要终止子进程时从子进程中调用。 retcode将提供给在父进程上执行的完成处理程序。
RedisModule_KillForkChild
int RedisModule_KillForkChild(int child_pid);可用于从父进程中杀死派生的子进程。 child_pid将是RedisModule_Fork的返回值。
RedisModule_SubscribeToServerEvent
int RedisModule_SubscribeToServerEvent(RedisModuleCtx *ctx, RedisModuleEvent event, RedisModuleEventCallback callback);当发生指定的服务器事件时，通过回调注册以得到通知。 使用事件作为参数调用该回调，并使用一个附加参数（该参数是一个空指针）并将其设置为特定于事件的特定类型（但许多事件将仅使用NULL，因为它们没有其他信息可以传递给该回调） 回调）。
如果回调为NULL，并且有先前的订阅，则该模块将被取消订阅。 如果以前有一个订阅，并且回调不为null，则旧的回调将被新的回调替代。
回调必须为以下类型：
- int (*RedisModuleEventCallback)(RedisModuleCtx *ctx, RedisModuleEvent eid, uint64_t subevent, void *data);
“ctx”是正常的Redis模块上下文，回调可以使用该上下文来调用其他模块的API。 'eid'是事件本身，仅在模块订阅了多个事件的情况下才有用：使用此结构的'id'字段，可以检查该事件是否是我们在此回调中注册的事件之一 。 “subevent”字段取决于触发的事件。
最后，仅对于某些事件，可以使用更相关的数据填充“数据”指针。
这是可以用作“eid”的事件和相关子事件的列表：
RedisModuleEvent_ReplicationRoleChanged
This event is called when the instance switches from master
to replica or the other way around, however the event is
also called when the replica remains a replica but starts to
replicate with a different master.
The following sub events are available:
REDISMODULE_SUBEVENT_REPLROLECHANGED_NOW_MASTER
REDISMODULE_SUBEVENT_REPLROLECHANGED_NOW_REPLICA
The 'data' field can be casted by the callback to a
RedisModuleReplicationInfo structure with the following fields:
int master; // true if master, false if replica
char *masterhost; // master instance hostname for NOW_REPLICA
int masterport; // master instance port for NOW_REPLICA
char *replid1; // Main replication ID
char *replid2; // Secondary replication ID
uint64_t repl1_offset; // Main replication offset
uint64_t repl2_offset; // Offset of replid2 validity
RedisModuleEvent_Persistence
This event is called when RDB saving or AOF rewriting starts
and ends. The following sub events are available:
REDISMODULE_SUBEVENT_PERSISTENCE_RDB_START
REDISMODULE_SUBEVENT_PERSISTENCE_AOF_START
REDISMODULE_SUBEVENT_PERSISTENCE_SYNC_RDB_START
REDISMODULE_SUBEVENT_PERSISTENCE_ENDED
REDISMODULE_SUBEVENT_PERSISTENCE_FAILED
The above events are triggered not just when the user calls the
relevant commands like BGSAVE, but also when a saving operation
or AOF rewriting occurs because of internal server triggers.
The SYNC_RDB_START sub events are happening in the forground due to
SAVE command, FLUSHALL, or server shutdown, and the other RDB and
AOF sub events are executed in a background fork child, so any
action the module takes can only affect the generated AOF or RDB,
but will not be reflected in the parent process and affect connected
clients and commands. Also note that the AOF_START sub event may end
up saving RDB content in case of an AOF with rdb-preamble.
RedisModuleEvent_FlushDB
The FLUSHALL, FLUSHDB or an internal flush (for instance
because of replication, after the replica synchronization)
happened. The following sub events are available:
REDISMODULE_SUBEVENT_FLUSHDB_START
REDISMODULE_SUBEVENT_FLUSHDB_END
The data pointer can be casted to a RedisModuleFlushInfo
structure with the following fields:
int32_t async; // True if the flush is done in a thread.
See for instance FLUSHALL ASYNC.
In this case the END callback is invoked
immediately after the database is put
in the free list of the thread.
int32_t dbnum; // Flushed database number, -1 for all the DBs
in the case of the FLUSHALL operation.
The start event is called *before* the operation is initated, thus
allowing the callback to call DBSIZE or other operation on the
yet-to-free keyspace.
RedisModuleEvent_Loading
Called on loading operations: at startup when the server is
started, but also after a first synchronization when the
replica is loading the RDB file from the master.
The following sub events are available:
REDISMODULE_SUBEVENT_LOADING_RDB_START
REDISMODULE_SUBEVENT_LOADING_AOF_START
REDISMODULE_SUBEVENT_LOADING_REPL_START
REDISMODULE_SUBEVENT_LOADING_ENDED
REDISMODULE_SUBEVENT_LOADING_FAILED
Note that AOF loading may start with an RDB data in case of
rdb-preamble, in which case you'll only receive an AOF_START event.
RedisModuleEvent_ClientChange
Called when a client connects or disconnects.
The data pointer can be casted to a RedisModuleClientInfo
structure, documented in RedisModule_GetClientInfoById().
The following sub events are available:
REDISMODULE_SUBEVENT_CLIENT_CHANGE_CONNECTED
REDISMODULE_SUBEVENT_CLIENT_CHANGE_DISCONNECTED
RedisModuleEvent_Shutdown
The server is shutting down. No subevents are available.RedisModuleEvent_ReplicaChange
This event is called when the instance (that can be both a
master or a replica) get a new online replica, or lose a
replica since it gets disconnected.
The following sub events are available:
REDISMODULE_SUBEVENT_REPLICA_CHANGE_ONLINE
REDISMODULE_SUBEVENT_REPLICA_CHANGE_OFFLINE
No additional information is available so far: future versions
of Redis will have an API in order to enumerate the replicas
connected and their state.RedisModuleEvent_CronLoop
This event is called every time Redis calls the serverCron()
function in order to do certain bookkeeping. Modules that are
required to do operations from time to time may use this callback.
Normally Redis calls this function 10 times per second, but
this changes depending on the "hz" configuration.
No sub events are available.
The data pointer can be casted to a RedisModuleCronLoop
structure with the following fields:
int32_t hz; // Approximate number of events per second.RedisModuleEvent_MasterLinkChange
This is called for replicas in order to notify when the
replication link becomes functional (up) with our master,
or when it goes down. Note that the link is not considered
up when we just connected to the master, but only if the
replication is happening correctly.
The following sub events are available:
REDISMODULE_SUBEVENT_MASTER_LINK_UP
REDISMODULE_SUBEVENT_MASTER_LINK_DOWNRedisModuleEvent_ModuleChange
This event is called when a new module is loaded or one is unloaded.
The following sub events are available:
REDISMODULE_SUBEVENT_MODULE_LOADED
REDISMODULE_SUBEVENT_MODULE_UNLOADED
The data pointer can be casted to a RedisModuleModuleChange
structure with the following fields:
const char* module_name; // Name of module loaded or unloaded.
int32_t module_version; // Module version.RedisModuleEvent_LoadingProgress
This event is called repeatedly called while an RDB or AOF file
is being loaded.
The following sub events are availble:
REDISMODULE_SUBEVENT_LOADING_PROGRESS_RDB
REDISMODULE_SUBEVENT_LOADING_PROGRESS_AOF
The data pointer can be casted to a RedisModuleLoadingProgress
structure with the following fields:
int32_t hz; // Approximate number of events per second.
int32_t progress; // Approximate progress between 0 and 1024,
or -1 if unknown.
RedisModuleEvent_SwapDB
This event is called when a swap db command has been successfully
Executed.
For this event call currently there is no subevents available.
The data pointer can be casted to a RedisModuleSwapDbInfo
structure with the following fields:
int32_t dbnum_first; // Swap Db first dbnum
int32_t dbnum_second; // Swap Db second dbnum 如果模块已成功预订指定事件，则该函数返回REDISMODULE_OK。 如果从错误的上下文中调用了API或给出了不受支持的事件，则返回REDISMODULE_ERR。
RedisModule_IsSubEventSupported
int RedisModule_IsSubEventSupported(RedisModuleEvent event, int64_t subevent);对于给定的服务器事件和子事件，如果不支持子事件，则返回零，否则返回非零。
RedisModule_SetLRU
int RedisModule_SetLRU(RedisModuleKey *key, mstime_t lru_idle);为基于LRU的驱逐设置关键的最后访问时间。 如果服务器的最大内存策略基于LFU，则不相关。 值是空闲时间（以毫秒为单位）。 如果LRU已更新，则返回REDISMODULE_OK，否则返回REDISMODULE_ERR。
RedisModule_GetLRU
int RedisModule_GetLRU(RedisModuleKey *key, mstime_t *lru_idle);获取键的最后访问时间。 如果服务器的逐出策略基于LFU，则值为以毫秒为单位的空闲时间或-1。 如果键有效，则返回REDISMODULE_OK。
RedisModule_SetLFU
int RedisModule_SetLFU(RedisModuleKey *key, long long lfu_freq);设置按键访问频率。 仅当服务器的最大内存策略基于LFU时才相关。 该频率是对数计数器，仅指示访问频率（必须<= 255）。 如果LFU已更新，则返回REDISMODULE_OK，否则返回REDISMODULE_ERR。
RedisModule_GetLFU
int RedisModule_GetLFU(RedisModuleKey *key, long long *lfu_freq);获取键访问频率；如果服务器的驱逐策略不是基于LFU的，则获取-1。 如果键有效，则返回REDISMODULE_OK。
RedisModule_GetContextFlagsAll
int RedisModule_GetContextFlagsAll();返回完整的ContextFlags掩码，使用返回值，模块可以检查所使用的Redis服务器版本是否支持某些标志集。
例：
int supportedFlags = RMGetContextFlagsAll() if (supportedFlags & REDISMODULECTXFLAGSMULTI) { // REDISMODULECTXFLAGSMULTI is supported } else{ // REDISMODULECTXFLAGSMULTI is not supported }
RedisModule_GetKeyspaceNotificationFlagsAll
int RedisModule_GetKeyspaceNotificationFlagsAll();返回完整的KeyspaceNotification掩码，使用返回值，模块可以检查所使用的Redis服务器版本是否支持某些标志集。
例：
int supportedFlags = RMGetKeyspaceNotificationFlagsAll() if (supportedFlags & REDISMODULENOTIFYLOADED) { // REDISMODULENOTIFYLOADED is supported } else{ // REDISMODULENOTIFY_LOADED is not supported }
RedisModule_GetServerVersion
int RedisModule_GetServerVersion();返回redis版本，格式为0x00MMmmpp。 对于6.0.7的示例，返回值为0x00060007。
RedisModule_ModuleTypeReplaceValue
int RedisModule_ModuleTypeReplaceValue(RedisModuleKey *key, moduleType *mt, void *new_value, void **old_value);替换分配给模块类型的值。
该键必须是开放的以便写入，并且必须具有现有值，并且必须具有与调用者指定的键匹配的moduleType。
与RM_ModuleTypeSetValue()会释放旧值不同，此函数只是将旧值与新值交换。
函数成功返回REDISMODULE_OK，错误返回REDISMODULE_ERR，例如：
- 键未打开进行写入。
- 键不是模块数据类型键。
- 键是'mt'以外的模块数据类型
如果old_value为非NULL，则通过引用返回旧值。
RedisModule_GetCommandKeys
int *RedisModule_GetCommandKeys(RedisModuleCtx *ctx, RedisModuleString **argv, int argc, int *num_keys);对于指定的命令，解析其参数并返回一个包含所有键名参数索引的数组。 从本质上讲，此功能是执行COMMAND GETKEYS的更有效方法。
返回值为NULL表示指定的命令没有键或错误情况。 通过将errno设置为以下内容来指示错误情况：
- ENOENT：指定的命令不存在。
- EINVAL：指定了无效的命令稀疏性。
注意：返回的数组不是Redis Module对象，因此即使使用自动内存也不会自动释放它。 调用者必须显式调用RM_Free()以释放它。
772
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
