mirror of
https://codeberg.org/redict/redict.git
synced 2025-01-22 08:08:53 -05:00
Rename symbols, part one
This commit is contained in:
Drew DeVault
parent
3fe17f47ba
commit
4680b58962
2
src/.gitignore
vendored
2
src/.gitignore
vendored
@ -1,5 +1,5 @@
|
||||
*.gcda
|
||||
*.gcno
|
||||
*.gcov
|
||||
redis.info
|
||||
redict.info
|
||||
lcov-html
|
||||
|
||||
32
src/acl.c
32
src/acl.c
@ -627,7 +627,7 @@ void ACLUpdateCommandRules(aclSelector *selector, const char *rule, int allow) {
|
||||
|
||||
/* This function is used to allow/block a specific command.
|
||||
* Allowing/blocking a container command also applies for its subcommands */
|
||||
void ACLChangeSelectorPerm(aclSelector *selector, struct redisCommand *cmd, int allow) {
|
||||
void ACLChangeSelectorPerm(aclSelector *selector, struct redictCommand *cmd, int allow) {
|
||||
unsigned long id = cmd->id;
|
||||
ACLSetSelectorCommandBit(selector,id,allow);
|
||||
ACLResetFirstArgsForCommand(selector,id);
|
||||
@ -635,7 +635,7 @@ void ACLChangeSelectorPerm(aclSelector *selector, struct redisCommand *cmd, int
|
||||
dictEntry *de;
|
||||
dictIterator *di = dictGetSafeIterator(cmd->subcommands_dict);
|
||||
while((de = dictNext(di)) != NULL) {
|
||||
struct redisCommand *sub = (struct redisCommand *)dictGetVal(de);
|
||||
struct redictCommand *sub = (struct redictCommand *)dictGetVal(de);
|
||||
ACLSetSelectorCommandBit(selector,sub->id,allow);
|
||||
}
|
||||
dictReleaseIterator(di);
|
||||
@ -652,7 +652,7 @@ void ACLSetSelectorCommandBitsForCategory(dict *commands, aclSelector *selector,
|
||||
dictIterator *di = dictGetIterator(commands);
|
||||
dictEntry *de;
|
||||
while ((de = dictNext(di)) != NULL) {
|
||||
struct redisCommand *cmd = dictGetVal(de);
|
||||
struct redictCommand *cmd = dictGetVal(de);
|
||||
if (cmd->acl_categories & cflag) {
|
||||
ACLChangeSelectorPerm(selector,cmd,value);
|
||||
}
|
||||
@ -716,7 +716,7 @@ void ACLCountCategoryBitsForCommands(dict *commands, aclSelector *selector, unsi
|
||||
dictIterator *di = dictGetIterator(commands);
|
||||
dictEntry *de;
|
||||
while ((de = dictNext(di)) != NULL) {
|
||||
struct redisCommand *cmd = dictGetVal(de);
|
||||
struct redictCommand *cmd = dictGetVal(de);
|
||||
if (cmd->acl_categories & cflag) {
|
||||
if (ACLGetSelectorCommandBit(selector,cmd->id))
|
||||
(*on)++;
|
||||
@ -900,8 +900,8 @@ robj *ACLDescribeUser(user *u) {
|
||||
/* Get a command from the original command table, that is not affected
|
||||
* by the command renaming operations: we base all the ACL work from that
|
||||
* table, so that ACLs are valid regardless of command renaming. */
|
||||
struct redisCommand *ACLLookupCommand(const char *name) {
|
||||
struct redisCommand *cmd;
|
||||
struct redictCommand *ACLLookupCommand(const char *name) {
|
||||
struct redictCommand *cmd;
|
||||
sds sdsname = sdsnew(name);
|
||||
cmd = lookupCommandBySdsLogic(server.orig_commands,sdsname);
|
||||
sdsfree(sdsname);
|
||||
@ -1118,7 +1118,7 @@ int ACLSetSelector(aclSelector *selector, const char* op, size_t oplen) {
|
||||
selector->flags &= ~SELECTOR_FLAG_ALLCHANNELS;
|
||||
} else if (op[0] == '+' && op[1] != '@') {
|
||||
if (strrchr(op,'|') == NULL) {
|
||||
struct redisCommand *cmd = ACLLookupCommand(op+1);
|
||||
struct redictCommand *cmd = ACLLookupCommand(op+1);
|
||||
if (cmd == NULL) {
|
||||
errno = ENOENT;
|
||||
return C_ERR;
|
||||
@ -1132,7 +1132,7 @@ int ACLSetSelector(aclSelector *selector, const char* op, size_t oplen) {
|
||||
sub[0] = '\0';
|
||||
sub++;
|
||||
|
||||
struct redisCommand *cmd = ACLLookupCommand(copy);
|
||||
struct redictCommand *cmd = ACLLookupCommand(copy);
|
||||
|
||||
/* Check if the command exists. We can't check the
|
||||
* first-arg to see if it is valid. */
|
||||
@ -1181,7 +1181,7 @@ int ACLSetSelector(aclSelector *selector, const char* op, size_t oplen) {
|
||||
zfree(copy);
|
||||
}
|
||||
} else if (op[0] == '-' && op[1] != '@') {
|
||||
struct redisCommand *cmd = ACLLookupCommand(op+1);
|
||||
struct redictCommand *cmd = ACLLookupCommand(op+1);
|
||||
if (cmd == NULL) {
|
||||
errno = ENOENT;
|
||||
return C_ERR;
|
||||
@ -1677,7 +1677,7 @@ void cleanupACLKeyResultCache(aclKeyResultCache *cache) {
|
||||
* command cannot be executed because the selector is not allowed to run such
|
||||
* command, the second and third if the command is denied because the selector is trying
|
||||
* to access a key or channel that are not among the specified patterns. */
|
||||
static int ACLSelectorCheckCmd(aclSelector *selector, struct redisCommand *cmd, robj **argv, int argc, int *keyidxptr, aclKeyResultCache *cache) {
|
||||
static int ACLSelectorCheckCmd(aclSelector *selector, struct redictCommand *cmd, robj **argv, int argc, int *keyidxptr, aclKeyResultCache *cache) {
|
||||
uint64_t id = cmd->id;
|
||||
int ret;
|
||||
if (!(selector->flags & SELECTOR_FLAG_ALLCOMMANDS) && !(cmd->flags & CMD_NO_AUTH)) {
|
||||
@ -1777,7 +1777,7 @@ int ACLUserCheckKeyPerm(user *u, const char *key, int keylen, int flags) {
|
||||
* granted in addition to the access required by the command. Returns 1
|
||||
* if the user has access or 0 otherwise.
|
||||
*/
|
||||
int ACLUserCheckCmdWithUnrestrictedKeyAccess(user *u, struct redisCommand *cmd, robj **argv, int argc, int flags) {
|
||||
int ACLUserCheckCmdWithUnrestrictedKeyAccess(user *u, struct redictCommand *cmd, robj **argv, int argc, int flags) {
|
||||
listIter li;
|
||||
listNode *ln;
|
||||
int local_idxptr;
|
||||
@ -1836,7 +1836,7 @@ int ACLUserCheckChannelPerm(user *u, sds channel, int is_pattern) {
|
||||
* If the command fails an ACL check, idxptr will be to set to the first argv entry that
|
||||
* causes the failure, either 0 if the command itself fails or the idx of the key/channel
|
||||
* that causes the failure */
|
||||
int ACLCheckAllUserCommandPerm(user *u, struct redisCommand *cmd, robj **argv, int argc, int *idxptr) {
|
||||
int ACLCheckAllUserCommandPerm(user *u, struct redictCommand *cmd, robj **argv, int argc, int *idxptr) {
|
||||
listIter li;
|
||||
listNode *ln;
|
||||
|
||||
@ -2732,7 +2732,7 @@ void addACLLogEntry(client *c, int reason, int context, int argpos, sds username
|
||||
}
|
||||
}
|
||||
|
||||
sds getAclErrorMessage(int acl_res, user *user, struct redisCommand *cmd, sds errored_val, int verbose) {
|
||||
sds getAclErrorMessage(int acl_res, user *user, struct redictCommand *cmd, sds errored_val, int verbose) {
|
||||
switch (acl_res) {
|
||||
case ACL_DENIED_CMD:
|
||||
return sdscatfmt(sdsempty(), "User %S has no permissions to run "
|
||||
@ -2765,7 +2765,7 @@ void aclCatWithFlags(client *c, dict *commands, uint64_t cflag, int *arraylen) {
|
||||
dictIterator *di = dictGetIterator(commands);
|
||||
|
||||
while ((de = dictNext(di)) != NULL) {
|
||||
struct redisCommand *cmd = dictGetVal(de);
|
||||
struct redictCommand *cmd = dictGetVal(de);
|
||||
if (cmd->flags & CMD_MODULE) continue;
|
||||
if (cmd->acl_categories & cflag) {
|
||||
addReplyBulkCBuffer(c, cmd->fullname, sdslen(cmd->fullname));
|
||||
@ -3105,7 +3105,7 @@ void aclCommand(client *c) {
|
||||
addReplyLongLong(c, le->ctime);
|
||||
}
|
||||
} else if (!strcasecmp(sub,"dryrun") && c->argc >= 4) {
|
||||
struct redisCommand *cmd;
|
||||
struct redictCommand *cmd;
|
||||
user *u = ACLGetUserByName(c->argv[2]->ptr,sdslen(c->argv[2]->ptr));
|
||||
if (u == NULL) {
|
||||
addReplyErrorFormat(c, "User '%s' not found", (char *)c->argv[2]->ptr);
|
||||
@ -3169,7 +3169,7 @@ NULL
|
||||
}
|
||||
}
|
||||
|
||||
void addReplyCommandCategories(client *c, struct redisCommand *cmd) {
|
||||
void addReplyCommandCategories(client *c, struct redictCommand *cmd) {
|
||||
int flagcount = 0;
|
||||
void *flaglen = addReplyDeferredLen(c);
|
||||
for (int j = 0; ACLCommandCategories[j].flag != 0; j++) {
|
||||
|
||||
@ -1459,7 +1459,7 @@ int loadSingleAppendOnlyFile(char *filename) {
|
||||
robj **argv;
|
||||
char buf[AOF_ANNOTATION_LINE_MAX_LEN];
|
||||
sds argsds;
|
||||
struct redisCommand *cmd;
|
||||
struct redictCommand *cmd;
|
||||
|
||||
/* Serve the clients from time to time */
|
||||
if (!(loops++ % 1024)) {
|
||||
|
||||
@ -47,6 +47,6 @@ struct commandDocs {
|
||||
char *params; /* A string describing the syntax of the command arguments. */
|
||||
};
|
||||
|
||||
extern struct commandDocs redisCommandTable[];
|
||||
extern struct commandDocs redictCommandTable[];
|
||||
|
||||
#endif
|
||||
|
||||
@ -968,7 +968,7 @@ void clusterCommand(client *c) {
|
||||
*
|
||||
* CLUSTER_REDIR_DOWN_STATE and CLUSTER_REDIR_DOWN_RO_STATE if the cluster is
|
||||
* down but the user attempts to execute a command that addresses one or more keys. */
|
||||
clusterNode *getNodeByQuery(client *c, struct redisCommand *cmd, robj **argv, int argc, int *hashslot, int *error_code) {
|
||||
clusterNode *getNodeByQuery(client *c, struct redictCommand *cmd, robj **argv, int argc, int *hashslot, int *error_code) {
|
||||
clusterNode *myself = getMyClusterNode();
|
||||
clusterNode *n = NULL;
|
||||
robj *firstkey = NULL;
|
||||
@ -1015,7 +1015,7 @@ clusterNode *getNodeByQuery(client *c, struct redisCommand *cmd, robj **argv, in
|
||||
/* Check that all the keys are in the same hash slot, and obtain this
|
||||
* slot and the node associated. */
|
||||
for (i = 0; i < ms->count; i++) {
|
||||
struct redisCommand *mcmd;
|
||||
struct redictCommand *mcmd;
|
||||
robj **margv;
|
||||
int margc, numkeys, j;
|
||||
keyReference *keyindex;
|
||||
|
||||
@ -111,7 +111,7 @@ long long clusterNodeReplOffset(clusterNode *node);
|
||||
clusterNode *clusterLookupNode(const char *name, int length);
|
||||
|
||||
/* functions with shared implementations */
|
||||
clusterNode *getNodeByQuery(client *c, struct redisCommand *cmd, robj **argv, int argc, int *hashslot, int *ask);
|
||||
clusterNode *getNodeByQuery(client *c, struct redictCommand *cmd, robj **argv, int argc, int *hashslot, int *ask);
|
||||
int clusterRedirectBlockedClientIfNeeded(client *c);
|
||||
void clusterRedirectClient(client *c, clusterNode *n, int hashslot, int error_code);
|
||||
void migrateCloseTimedoutSockets(void);
|
||||
|
||||
@ -9,8 +9,8 @@
|
||||
|
||||
#define MAKE_CMD(name,summary,complexity,since,doc_flags,replaced,deprecated,group,group_enum,history,num_history,tips,num_tips,function,arity,flags,acl,key_specs,key_specs_num,get_keys,numargs) name,summary,complexity,since,doc_flags,replaced,deprecated,group_enum,history,num_history,tips,num_tips,function,arity,flags,acl,key_specs,key_specs_num,get_keys,numargs
|
||||
#define MAKE_ARG(name,type,key_spec_index,token,summary,since,flags,numsubargs,deprecated_since) name,type,key_spec_index,token,summary,since,flags,deprecated_since,numsubargs
|
||||
#define COMMAND_STRUCT redisCommand
|
||||
#define COMMAND_ARG redisCommandArg
|
||||
#define COMMAND_STRUCT redictCommand
|
||||
#define COMMAND_ARG redictCommandArg
|
||||
|
||||
#ifdef LOG_REQ_RES
|
||||
#include "commands_with_reply_schema.def"
|
||||
|
||||
@ -3,9 +3,9 @@
|
||||
|
||||
/* We have fabulous commands from
|
||||
* the fantastic
|
||||
* Redis Command Table! */
|
||||
* Redict Command Table! */
|
||||
|
||||
/* Must match redisCommandGroup */
|
||||
/* Must match redictCommandGroup */
|
||||
const char *COMMAND_GROUP_STR[] = {
|
||||
"generic",
|
||||
"string",
|
||||
@ -10643,7 +10643,7 @@ struct COMMAND_ARG WATCH_Args[] = {
|
||||
};
|
||||
|
||||
/* Main command table */
|
||||
struct COMMAND_STRUCT redisCommandTable[] = {
|
||||
struct COMMAND_STRUCT redictCommandTable[] = {
|
||||
/* bitmap */
|
||||
{MAKE_CMD("bitcount","Counts the number of set bits (population counting) in a string.","O(N)","2.6.0",CMD_DOC_NONE,NULL,NULL,"bitmap",COMMAND_GROUP_BITMAP,BITCOUNT_History,1,BITCOUNT_Tips,0,bitcountCommand,-2,CMD_READONLY,ACL_CATEGORY_BITMAP,BITCOUNT_Keyspecs,1,NULL,2),.args=BITCOUNT_Args},
|
||||
{MAKE_CMD("bitfield","Performs arbitrary bitfield integer operations on strings.","O(1) for each subcommand specified","3.2.0",CMD_DOC_NONE,NULL,NULL,"bitmap",COMMAND_GROUP_BITMAP,BITFIELD_History,0,BITFIELD_Tips,0,bitfieldCommand,-2,CMD_WRITE|CMD_DENYOOM,ACL_CATEGORY_BITMAP,BITFIELD_Keyspecs,1,bitfieldGetKeys,2),.args=BITFIELD_Args},
|
||||
|
||||
@ -26,7 +26,7 @@ typedef enum {
|
||||
#define CMD_ARG_MULTIPLE_TOKEN (1<<2)
|
||||
|
||||
/* Must be compatible with RedisModuleCommandArg. See moduleCopyCommandArgs. */
|
||||
typedef struct redisCommandArg {
|
||||
typedef struct redictCommandArg {
|
||||
const char *name;
|
||||
redisCommandArgType type;
|
||||
int key_spec_index;
|
||||
@ -36,7 +36,7 @@ typedef struct redisCommandArg {
|
||||
int flags;
|
||||
const char *deprecated_since;
|
||||
int num_args;
|
||||
struct redisCommandArg *subargs;
|
||||
struct redictCommandArg *subargs;
|
||||
const char *display_text;
|
||||
} redisCommandArg;
|
||||
|
||||
|
||||
@ -514,7 +514,7 @@ void loadServerConfigFromString(char *config) {
|
||||
if (!strcasecmp(argv[0],"include") && argc == 2) {
|
||||
loadServerConfig(argv[1], 0, NULL);
|
||||
} else if (!strcasecmp(argv[0],"rename-command") && argc == 3) {
|
||||
struct redisCommand *cmd = lookupCommandBySds(argv[1]);
|
||||
struct redictCommand *cmd = lookupCommandBySds(argv[1]);
|
||||
int retval;
|
||||
|
||||
if (!cmd) {
|
||||
|
||||
50
src/db.c
50
src/db.c
@ -1947,7 +1947,7 @@ keyReference *getKeysPrepareResult(getKeysResult *result, int numkeys) {
|
||||
|
||||
/* Returns a bitmask with all the flags found in any of the key specs of the command.
|
||||
* The 'inv' argument means we'll return a mask with all flags that are missing in at least one spec. */
|
||||
int64_t getAllKeySpecsFlags(struct redisCommand *cmd, int inv) {
|
||||
int64_t getAllKeySpecsFlags(struct redictCommand *cmd, int inv) {
|
||||
int64_t flags = 0;
|
||||
for (int j = 0; j < cmd->key_specs_num; j++) {
|
||||
keySpec *spec = cmd->key_specs + j;
|
||||
@ -1963,7 +1963,7 @@ int64_t getAllKeySpecsFlags(struct redisCommand *cmd, int inv) {
|
||||
* GET_KEYSPEC_RETURN_PARTIAL: Skips invalid and incomplete keyspecs but returns the keys
|
||||
* found in other valid keyspecs.
|
||||
*/
|
||||
int getKeysUsingKeySpecs(struct redisCommand *cmd, robj **argv, int argc, int search_flags, getKeysResult *result) {
|
||||
int getKeysUsingKeySpecs(struct redictCommand *cmd, robj **argv, int argc, int search_flags, getKeysResult *result) {
|
||||
int j, i, last, first, step;
|
||||
keyReference *keys;
|
||||
serverAssert(result->numkeys == 0); /* caller should initialize or reset it */
|
||||
@ -2090,7 +2090,7 @@ invalid_spec:
|
||||
*
|
||||
* 'cmd' must be point to the corresponding entry into the redisCommand
|
||||
* table, according to the command name in argv[0]. */
|
||||
int getKeysFromCommandWithSpecs(struct redisCommand *cmd, robj **argv, int argc, int search_flags, getKeysResult *result) {
|
||||
int getKeysFromCommandWithSpecs(struct redictCommand *cmd, robj **argv, int argc, int search_flags, getKeysResult *result) {
|
||||
/* The command has at least one key-spec not marked as NOT_KEY */
|
||||
int has_keyspec = (getAllKeySpecsFlags(cmd, 1) & CMD_KEY_NOT_KEY);
|
||||
/* The command has at least one key-spec marked as VARIABLE_FLAGS */
|
||||
@ -2117,7 +2117,7 @@ int getKeysFromCommandWithSpecs(struct redisCommand *cmd, robj **argv, int argc,
|
||||
}
|
||||
|
||||
/* This function returns a sanity check if the command may have keys. */
|
||||
int doesCommandHaveKeys(struct redisCommand *cmd) {
|
||||
int doesCommandHaveKeys(struct redictCommand *cmd) {
|
||||
return cmd->getkeys_proc || /* has getkeys_proc (non modules) */
|
||||
(cmd->flags & CMD_MODULE_GETKEYS) || /* module with GETKEYS */
|
||||
(getAllKeySpecsFlags(cmd, 1) & CMD_KEY_NOT_KEY); /* has at least one key-spec not marked as NOT_KEY */
|
||||
@ -2126,7 +2126,7 @@ int doesCommandHaveKeys(struct redisCommand *cmd) {
|
||||
/* A simplified channel spec table that contains all of the redis commands
|
||||
* and which channels they have and how they are accessed. */
|
||||
typedef struct ChannelSpecs {
|
||||
redisCommandProc *proc; /* Command procedure to match against */
|
||||
redictCommandProc *proc; /* Command procedure to match against */
|
||||
uint64_t flags; /* CMD_CHANNEL_* flags for this command */
|
||||
int start; /* The initial position of the first channel */
|
||||
int count; /* The number of channels, or -1 if all remaining
|
||||
@ -2147,7 +2147,7 @@ ChannelSpecs commands_with_channels[] = {
|
||||
|
||||
/* Returns 1 if the command may access any channels matched by the flags
|
||||
* argument. */
|
||||
int doesCommandHaveChannelsWithFlags(struct redisCommand *cmd, int flags) {
|
||||
int doesCommandHaveChannelsWithFlags(struct redictCommand *cmd, int flags) {
|
||||
/* If a module declares get channels, we are just going to assume
|
||||
* has channels. This API is allowed to return false positives. */
|
||||
if (cmd->flags & CMD_MODULE_GETCHANNELS) {
|
||||
@ -2174,7 +2174,7 @@ int doesCommandHaveChannelsWithFlags(struct redisCommand *cmd, int flags) {
|
||||
*
|
||||
* 'cmd' must be point to the corresponding entry into the redisCommand
|
||||
* table, according to the command name in argv[0]. */
|
||||
int getChannelsFromCommand(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int getChannelsFromCommand(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
keyReference *keys;
|
||||
/* If a module declares get channels, use that. */
|
||||
if (cmd->flags & CMD_MODULE_GETCHANNELS) {
|
||||
@ -2209,7 +2209,7 @@ int getChannelsFromCommand(struct redisCommand *cmd, robj **argv, int argc, getK
|
||||
*
|
||||
* NOTE: This function does not guarantee populating the flags for
|
||||
* the keys, in order to get flags you should use getKeysUsingKeySpecs. */
|
||||
int getKeysUsingLegacyRangeSpec(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int getKeysUsingLegacyRangeSpec(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int j, i = 0, last, first, step;
|
||||
keyReference *keys;
|
||||
UNUSED(argv);
|
||||
@ -2264,7 +2264,7 @@ int getKeysUsingLegacyRangeSpec(struct redisCommand *cmd, robj **argv, int argc,
|
||||
*
|
||||
* This function uses the command table if a command-specific helper function
|
||||
* is not required, otherwise it calls the command-specific function. */
|
||||
int getKeysFromCommand(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int getKeysFromCommand(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
if (cmd->flags & CMD_MODULE_GETKEYS) {
|
||||
return moduleGetCommandKeysViaAPI(cmd,argv,argc,result);
|
||||
} else if (cmd->getkeys_proc) {
|
||||
@ -2323,47 +2323,47 @@ int genericGetKeys(int storeKeyOfs, int keyCountOfs, int firstKeyOfs, int keySte
|
||||
return result->numkeys;
|
||||
}
|
||||
|
||||
int sintercardGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int sintercardGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
UNUSED(cmd);
|
||||
return genericGetKeys(0, 1, 2, 1, argv, argc, result);
|
||||
}
|
||||
|
||||
int zunionInterDiffStoreGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int zunionInterDiffStoreGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
UNUSED(cmd);
|
||||
return genericGetKeys(1, 2, 3, 1, argv, argc, result);
|
||||
}
|
||||
|
||||
int zunionInterDiffGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int zunionInterDiffGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
UNUSED(cmd);
|
||||
return genericGetKeys(0, 1, 2, 1, argv, argc, result);
|
||||
}
|
||||
|
||||
int evalGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int evalGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
UNUSED(cmd);
|
||||
return genericGetKeys(0, 2, 3, 1, argv, argc, result);
|
||||
}
|
||||
|
||||
int functionGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int functionGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
UNUSED(cmd);
|
||||
return genericGetKeys(0, 2, 3, 1, argv, argc, result);
|
||||
}
|
||||
|
||||
int lmpopGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int lmpopGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
UNUSED(cmd);
|
||||
return genericGetKeys(0, 1, 2, 1, argv, argc, result);
|
||||
}
|
||||
|
||||
int blmpopGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int blmpopGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
UNUSED(cmd);
|
||||
return genericGetKeys(0, 2, 3, 1, argv, argc, result);
|
||||
}
|
||||
|
||||
int zmpopGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int zmpopGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
UNUSED(cmd);
|
||||
return genericGetKeys(0, 1, 2, 1, argv, argc, result);
|
||||
}
|
||||
|
||||
int bzmpopGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int bzmpopGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
UNUSED(cmd);
|
||||
return genericGetKeys(0, 2, 3, 1, argv, argc, result);
|
||||
}
|
||||
@ -2378,7 +2378,7 @@ int bzmpopGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult
|
||||
* implementation to fetch the keys.
|
||||
*
|
||||
* This command declares incomplete keys, so the flags are correctly set for this function */
|
||||
int sortROGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int sortROGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
keyReference *keys;
|
||||
UNUSED(cmd);
|
||||
UNUSED(argv);
|
||||
@ -2400,7 +2400,7 @@ int sortROGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult
|
||||
* correctly identify keys in the "STORE" option.
|
||||
*
|
||||
* This command declares incomplete keys, so the flags are correctly set for this function */
|
||||
int sortGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int sortGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int i, j, num, found_store = 0;
|
||||
keyReference *keys;
|
||||
UNUSED(cmd);
|
||||
@ -2445,7 +2445,7 @@ int sortGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *
|
||||
}
|
||||
|
||||
/* This command declares incomplete keys, so the flags are correctly set for this function */
|
||||
int migrateGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int migrateGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int i, j, num, first;
|
||||
keyReference *keys;
|
||||
UNUSED(cmd);
|
||||
@ -2502,7 +2502,7 @@ int migrateGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResul
|
||||
* GEORADIUSBYMEMBER key member radius unit ... options ...
|
||||
*
|
||||
* This command has a fully defined keyspec, so returning flags isn't needed. */
|
||||
int georadiusGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int georadiusGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int i, num;
|
||||
keyReference *keys;
|
||||
UNUSED(cmd);
|
||||
@ -2543,7 +2543,7 @@ int georadiusGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysRes
|
||||
* STREAMS key_1 key_2 ... key_N ID_1 ID_2 ... ID_N
|
||||
*
|
||||
* This command has a fully defined keyspec, so returning flags isn't needed. */
|
||||
int xreadGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int xreadGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int i, num = 0;
|
||||
keyReference *keys;
|
||||
UNUSED(cmd);
|
||||
@ -2591,7 +2591,7 @@ int xreadGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult
|
||||
|
||||
/* Helper function to extract keys from the SET command, which may have
|
||||
* a read flag if the GET argument is passed in. */
|
||||
int setGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int setGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
keyReference *keys;
|
||||
UNUSED(cmd);
|
||||
|
||||
@ -2616,7 +2616,7 @@ int setGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *r
|
||||
|
||||
/* Helper function to extract keys from the BITFIELD command, which may be
|
||||
* read-only if the BITFIELD GET subcommand is used. */
|
||||
int bitfieldGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int bitfieldGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
keyReference *keys;
|
||||
int readonly = 1;
|
||||
UNUSED(cmd);
|
||||
|
||||
@ -465,10 +465,10 @@ void fillCommandCDF(client *c, struct hdr_histogram* histogram) {
|
||||
void latencyAllCommandsFillCDF(client *c, dict *commands, int *command_with_data) {
|
||||
dictIterator *di = dictGetSafeIterator(commands);
|
||||
dictEntry *de;
|
||||
struct redisCommand *cmd;
|
||||
struct redictCommand *cmd;
|
||||
|
||||
while((de = dictNext(di)) != NULL) {
|
||||
cmd = (struct redisCommand *) dictGetVal(de);
|
||||
cmd = (struct redictCommand *) dictGetVal(de);
|
||||
if (cmd->latency_histogram) {
|
||||
addReplyBulkCBuffer(c, cmd->fullname, sdslen(cmd->fullname));
|
||||
fillCommandCDF(c, cmd->latency_histogram);
|
||||
@ -488,7 +488,7 @@ void latencySpecificCommandsFillCDF(client *c) {
|
||||
void *replylen = addReplyDeferredLen(c);
|
||||
int command_with_data = 0;
|
||||
for (int j = 2; j < c->argc; j++){
|
||||
struct redisCommand *cmd = lookupCommandBySds(c->argv[j]->ptr);
|
||||
struct redictCommand *cmd = lookupCommandBySds(c->argv[j]->ptr);
|
||||
/* If the command does not exist we skip the reply */
|
||||
if (cmd == NULL) {
|
||||
continue;
|
||||
@ -505,7 +505,7 @@ void latencySpecificCommandsFillCDF(client *c) {
|
||||
dictIterator *di = dictGetSafeIterator(cmd->subcommands_dict);
|
||||
|
||||
while ((de = dictNext(di)) != NULL) {
|
||||
struct redisCommand *sub = dictGetVal(de);
|
||||
struct redictCommand *sub = dictGetVal(de);
|
||||
if (sub->latency_histogram) {
|
||||
addReplyBulkCBuffer(c, sub->fullname, sdslen(sub->fullname));
|
||||
fillCommandCDF(c, sub->latency_histogram);
|
||||
|
||||
52
src/module.c
52
src/module.c
@ -213,12 +213,12 @@ typedef int (*RedisModuleAuthCallback)(RedisModuleCtx *ctx, void *username, void
|
||||
typedef void (*RedisModuleDisconnectFunc) (RedisModuleCtx *ctx, struct RedisModuleBlockedClient *bc);
|
||||
|
||||
/* This struct holds the information about a command registered by a module.*/
|
||||
struct RedisModuleCommand {
|
||||
struct RedictModuleCommand {
|
||||
struct RedisModule *module;
|
||||
RedisModuleCmdFunc func;
|
||||
struct redisCommand *rediscmd;
|
||||
struct redictCommand *rediscmd;
|
||||
};
|
||||
typedef struct RedisModuleCommand RedisModuleCommand;
|
||||
typedef struct RedictModuleCommand RedisModuleCommand;
|
||||
|
||||
#define REDISMODULE_REPLYFLAG_NONE 0
|
||||
#define REDISMODULE_REPLYFLAG_TOPARSE (1<<0) /* Protocol must be parsed. */
|
||||
@ -478,7 +478,7 @@ static int moduleValidateCommandInfo(const RedisModuleCommandInfo *info);
|
||||
static int64_t moduleConvertKeySpecsFlags(int64_t flags, int from_api);
|
||||
static int moduleValidateCommandArgs(RedisModuleCommandArg *args,
|
||||
const RedisModuleCommandInfoVersion *version);
|
||||
static struct redisCommandArg *moduleCopyCommandArgs(RedisModuleCommandArg *args,
|
||||
static struct redictCommandArg *moduleCopyCommandArgs(RedisModuleCommandArg *args,
|
||||
const RedisModuleCommandInfoVersion *version);
|
||||
static redisCommandArgType moduleConvertArgType(RedisModuleCommandArgType type, int *error);
|
||||
static int moduleConvertArgFlags(int flags);
|
||||
@ -937,7 +937,7 @@ void RedisModuleCommandDispatcher(client *c) {
|
||||
* In order to accomplish its work, the module command is called, flagging
|
||||
* the context in a way that the command can recognize this is a special
|
||||
* "get keys" call by calling RedisModule_IsKeysPositionRequest(ctx). */
|
||||
int moduleGetCommandKeysViaAPI(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int moduleGetCommandKeysViaAPI(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
RedisModuleCommand *cp = cmd->module_cmd;
|
||||
RedisModuleCtx ctx;
|
||||
moduleCreateContext(&ctx, cp->module, REDISMODULE_CTX_KEYS_POS_REQUEST);
|
||||
@ -957,7 +957,7 @@ int moduleGetCommandKeysViaAPI(struct redisCommand *cmd, robj **argv, int argc,
|
||||
/* This function returns the list of channels, with the same interface as
|
||||
* moduleGetCommandKeysViaAPI, for modules that declare "getchannels-api"
|
||||
* during registration. Unlike keys, this is the only way to declare channels. */
|
||||
int moduleGetCommandChannelsViaAPI(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
int moduleGetCommandChannelsViaAPI(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result) {
|
||||
RedisModuleCommand *cp = cmd->module_cmd;
|
||||
RedisModuleCtx ctx;
|
||||
moduleCreateContext(&ctx, cp->module, REDISMODULE_CTX_CHANNELS_POS_REQUEST);
|
||||
@ -1279,7 +1279,7 @@ int RM_CreateCommand(RedisModuleCtx *ctx, const char *name, RedisModuleCmdFunc c
|
||||
* Function will take the ownership of both 'declared_name' and 'fullname' SDS.
|
||||
*/
|
||||
RedisModuleCommand *moduleCreateCommandProxy(struct RedisModule *module, sds declared_name, sds fullname, RedisModuleCmdFunc cmdfunc, int64_t flags, int firstkey, int lastkey, int keystep) {
|
||||
struct redisCommand *rediscmd;
|
||||
struct redictCommand *rediscmd;
|
||||
RedisModuleCommand *cp;
|
||||
|
||||
/* Create a command "proxy", which is a structure that is referenced
|
||||
@ -1330,7 +1330,7 @@ RedisModuleCommand *moduleCreateCommandProxy(struct RedisModule *module, sds dec
|
||||
* * The command doesn't belong to the calling module
|
||||
*/
|
||||
RedisModuleCommand *RM_GetCommand(RedisModuleCtx *ctx, const char *name) {
|
||||
struct redisCommand *cmd = lookupCommandByCString(name);
|
||||
struct redictCommand *cmd = lookupCommandByCString(name);
|
||||
|
||||
if (!cmd || !(cmd->flags & CMD_MODULE))
|
||||
return NULL;
|
||||
@ -1377,7 +1377,7 @@ int RM_CreateSubcommand(RedisModuleCommand *parent, const char *name, RedisModul
|
||||
if ((flags & CMD_MODULE_NO_CLUSTER) && server.cluster_enabled)
|
||||
return REDISMODULE_ERR;
|
||||
|
||||
struct redisCommand *parent_cmd = parent->rediscmd;
|
||||
struct redictCommand *parent_cmd = parent->rediscmd;
|
||||
|
||||
if (parent_cmd->parent)
|
||||
return REDISMODULE_ERR; /* We don't allow more than one level of subcommands */
|
||||
@ -1428,7 +1428,7 @@ moduleCmdArgAt(const RedisModuleCommandInfoVersion *version,
|
||||
|
||||
/* Recursively populate the args structure (setting num_args to the number of
|
||||
* subargs) and return the number of args. */
|
||||
int populateArgsStructure(struct redisCommandArg *args) {
|
||||
int populateArgsStructure(struct redictCommandArg *args) {
|
||||
if (!args)
|
||||
return 0;
|
||||
int count = 0;
|
||||
@ -1531,7 +1531,7 @@ int RM_SetCommandACLCategories(RedisModuleCommand *command, const char *aclflags
|
||||
if (!command || !command->module || !command->module->onload) return REDISMODULE_ERR;
|
||||
int64_t categories_flags = aclflags ? categoryFlagsFromString((char*)aclflags) : 0;
|
||||
if (categories_flags == -1) return REDISMODULE_ERR;
|
||||
struct redisCommand *rcmd = command->rediscmd;
|
||||
struct redictCommand *rcmd = command->rediscmd;
|
||||
rcmd->acl_categories = categories_flags; /* ACL categories flags for module command */
|
||||
command->module->num_commands_with_acl_categories++;
|
||||
return REDISMODULE_OK;
|
||||
@ -1844,7 +1844,7 @@ int RM_SetCommandInfo(RedisModuleCommand *command, const RedisModuleCommandInfo
|
||||
return REDISMODULE_ERR;
|
||||
}
|
||||
|
||||
struct redisCommand *cmd = command->rediscmd;
|
||||
struct redictCommand *cmd = command->rediscmd;
|
||||
|
||||
/* Check if any info has already been set. Overwriting info involves freeing
|
||||
* the old info, which is not implemented. */
|
||||
@ -2175,13 +2175,13 @@ static int moduleValidateCommandArgs(RedisModuleCommandArg *args,
|
||||
}
|
||||
|
||||
/* Converts an array of RedisModuleCommandArg into a freshly allocated array of
|
||||
* struct redisCommandArg. */
|
||||
static struct redisCommandArg *moduleCopyCommandArgs(RedisModuleCommandArg *args,
|
||||
* struct redictCommandArg. */
|
||||
static struct redictCommandArg *moduleCopyCommandArgs(RedisModuleCommandArg *args,
|
||||
const RedisModuleCommandInfoVersion *version) {
|
||||
size_t count = 0;
|
||||
while (moduleCmdArgAt(version, args, count)->name) count++;
|
||||
serverAssert(count < SIZE_MAX / sizeof(struct redisCommandArg));
|
||||
struct redisCommandArg *realargs = zcalloc((count+1) * sizeof(redisCommandArg));
|
||||
serverAssert(count < SIZE_MAX / sizeof(struct redictCommandArg));
|
||||
struct redictCommandArg *realargs = zcalloc((count+1) * sizeof(redisCommandArg));
|
||||
|
||||
for (size_t j = 0; j < count; j++) {
|
||||
RedisModuleCommandArg *arg = moduleCmdArgAt(version, args, j);
|
||||
@ -2234,7 +2234,7 @@ void *moduleGetHandleByName(char *modulename) {
|
||||
}
|
||||
|
||||
/* Returns 1 if `cmd` is a command of the module `modulename`. 0 otherwise. */
|
||||
int moduleIsModuleCommand(void *module_handle, struct redisCommand *cmd) {
|
||||
int moduleIsModuleCommand(void *module_handle, struct redictCommand *cmd) {
|
||||
if (cmd->proc != RedisModuleCommandDispatcher)
|
||||
return 0;
|
||||
if (module_handle == NULL)
|
||||
@ -3556,7 +3556,7 @@ int RM_ReplyWithLongDouble(RedisModuleCtx *ctx, long double ld) {
|
||||
* The command returns REDISMODULE_ERR if the format specifiers are invalid
|
||||
* or the command name does not belong to a known command. */
|
||||
int RM_Replicate(RedisModuleCtx *ctx, const char *cmdname, const char *fmt, ...) {
|
||||
struct redisCommand *cmd;
|
||||
struct redictCommand *cmd;
|
||||
robj **argv = NULL;
|
||||
int argc = 0, flags = 0, j;
|
||||
va_list ap;
|
||||
@ -6751,7 +6751,7 @@ const char *moduleTypeModuleName(moduleType *mt) {
|
||||
}
|
||||
|
||||
/* Return the module name from a module command */
|
||||
const char *moduleNameFromCommand(struct redisCommand *cmd) {
|
||||
const char *moduleNameFromCommand(struct redictCommand *cmd) {
|
||||
serverAssert(cmd->proc == RedisModuleCommandDispatcher);
|
||||
|
||||
RedisModuleCommand *cp = cmd->module_cmd;
|
||||
@ -7506,7 +7506,7 @@ int RM_GetDbIdFromDigest(RedisModuleDigest *dig) {
|
||||
* handling is performed by Redis itself. */
|
||||
void RM_EmitAOF(RedisModuleIO *io, const char *cmdname, const char *fmt, ...) {
|
||||
if (io->error) return;
|
||||
struct redisCommand *cmd;
|
||||
struct redictCommand *cmd;
|
||||
robj **argv = NULL;
|
||||
int argc = 0, flags = 0, j;
|
||||
va_list ap;
|
||||
@ -9700,7 +9700,7 @@ RedisModuleUser *RM_GetModuleUserFromUserName(RedisModuleString *name) {
|
||||
*/
|
||||
int RM_ACLCheckCommandPermissions(RedisModuleUser *user, RedisModuleString **argv, int argc) {
|
||||
int keyidxptr;
|
||||
struct redisCommand *cmd;
|
||||
struct redictCommand *cmd;
|
||||
|
||||
/* Find command */
|
||||
if ((cmd = lookupCommand(argv, argc)) == NULL) {
|
||||
@ -12103,7 +12103,7 @@ void moduleFreeModuleStructure(struct RedisModule *module) {
|
||||
zfree(module);
|
||||
}
|
||||
|
||||
void moduleFreeArgs(struct redisCommandArg *args, int num_args) {
|
||||
void moduleFreeArgs(struct redictCommandArg *args, int num_args) {
|
||||
for (int j = 0; j < num_args; j++) {
|
||||
zfree((char *)args[j].name);
|
||||
zfree((char *)args[j].token);
|
||||
@ -12125,7 +12125,7 @@ void moduleFreeArgs(struct redisCommandArg *args, int num_args) {
|
||||
* Note that caller needs to handle the deletion of the command table dict,
|
||||
* and after that needs to free the command->fullname and the command itself.
|
||||
*/
|
||||
int moduleFreeCommand(struct RedisModule *module, struct redisCommand *cmd) {
|
||||
int moduleFreeCommand(struct RedisModule *module, struct redictCommand *cmd) {
|
||||
if (cmd->proc != RedisModuleCommandDispatcher)
|
||||
return C_ERR;
|
||||
|
||||
@ -12164,7 +12164,7 @@ int moduleFreeCommand(struct RedisModule *module, struct redisCommand *cmd) {
|
||||
dictEntry *de;
|
||||
dictIterator *di = dictGetSafeIterator(cmd->subcommands_dict);
|
||||
while ((de = dictNext(di)) != NULL) {
|
||||
struct redisCommand *sub = dictGetVal(de);
|
||||
struct redictCommand *sub = dictGetVal(de);
|
||||
if (moduleFreeCommand(module, sub) != C_OK) continue;
|
||||
|
||||
serverAssert(dictDelete(cmd->subcommands_dict, sub->declared_name) == DICT_OK);
|
||||
@ -12184,7 +12184,7 @@ void moduleUnregisterCommands(struct RedisModule *module) {
|
||||
dictIterator *di = dictGetSafeIterator(server.commands);
|
||||
dictEntry *de;
|
||||
while ((de = dictNext(di)) != NULL) {
|
||||
struct redisCommand *cmd = dictGetVal(de);
|
||||
struct redictCommand *cmd = dictGetVal(de);
|
||||
if (moduleFreeCommand(module, cmd) != C_OK) continue;
|
||||
|
||||
serverAssert(dictDelete(server.commands, cmd->fullname) == DICT_OK);
|
||||
@ -13334,7 +13334,7 @@ int RM_ModuleTypeReplaceValue(RedisModuleKey *key, moduleType *mt, void *new_val
|
||||
*/
|
||||
int *RM_GetCommandKeysWithFlags(RedisModuleCtx *ctx, RedisModuleString **argv, int argc, int *num_keys, int **out_flags) {
|
||||
UNUSED(ctx);
|
||||
struct redisCommand *cmd;
|
||||
struct redictCommand *cmd;
|
||||
int *res = NULL;
|
||||
|
||||
/* Find command */
|
||||
|
||||
@ -127,7 +127,7 @@ void execCommand(client *c) {
|
||||
int j;
|
||||
robj **orig_argv;
|
||||
int orig_argc, orig_argv_len;
|
||||
struct redisCommand *orig_cmd;
|
||||
struct redictCommand *orig_cmd;
|
||||
|
||||
if (!(c->flags & CLIENT_MULTI)) {
|
||||
addReplyError(c,"EXEC without MULTI");
|
||||
|
||||
@ -363,7 +363,7 @@ void _addReplyProtoToList(client *c, list *reply_list, const char *s, size_t len
|
||||
/* The subscribe / unsubscribe command family has a push as a reply,
|
||||
* or in other words, it responds with a push (or several of them
|
||||
* depending on how many arguments it got), and has no reply. */
|
||||
int cmdHasPushAsReply(struct redisCommand *cmd) {
|
||||
int cmdHasPushAsReply(struct redictCommand *cmd) {
|
||||
if (!cmd) return 0;
|
||||
return cmd->proc == subscribeCommand || cmd->proc == unsubscribeCommand ||
|
||||
cmd->proc == psubscribeCommand || cmd->proc == punsubscribeCommand ||
|
||||
@ -2053,7 +2053,7 @@ int handleClientsWithPendingWrites(void) {
|
||||
|
||||
/* resetClient prepare the client to process the next command */
|
||||
void resetClient(client *c) {
|
||||
redisCommandProc *prevcmd = c->cmd ? c->cmd->proc : NULL;
|
||||
redictCommandProc *prevcmd = c->cmd ? c->cmd->proc : NULL;
|
||||
|
||||
freeClientArgv(c);
|
||||
c->cur_script = NULL;
|
||||
|
||||
@ -855,10 +855,10 @@ static void cliLegacyInitHelp(dict *groups) {
|
||||
sds serverVersion = cliGetServerVersion();
|
||||
|
||||
/* Scan the commandDocs array and fill in the entries */
|
||||
helpEntriesLen = cliLegacyCountCommands(redisCommandTable, serverVersion);
|
||||
helpEntriesLen = cliLegacyCountCommands(redictCommandTable, serverVersion);
|
||||
helpEntries = zmalloc(sizeof(helpEntry)*helpEntriesLen);
|
||||
|
||||
helpEntriesLen = cliLegacyInitCommandHelpEntries(redisCommandTable, groups, serverVersion);
|
||||
helpEntriesLen = cliLegacyInitCommandHelpEntries(redictCommandTable, groups, serverVersion);
|
||||
cliInitGroupHelpEntries(groups);
|
||||
|
||||
qsort(helpEntries, helpEntriesLen, sizeof(helpEntry), helpEntryCompare);
|
||||
|
||||
@ -297,7 +297,7 @@ void scriptKill(client *c, int is_eval) {
|
||||
addReply(c, shared.ok);
|
||||
}
|
||||
|
||||
static int scriptVerifyCommandArity(struct redisCommand *cmd, int argc, sds *err) {
|
||||
static int scriptVerifyCommandArity(struct redictCommand *cmd, int argc, sds *err) {
|
||||
if (!cmd || ((cmd->arity > 0 && cmd->arity != argc) || (argc < -cmd->arity))) {
|
||||
if (cmd)
|
||||
*err = sdsnew("Wrong number of args calling Redict command from script");
|
||||
@ -519,7 +519,7 @@ void scriptCall(scriptRunCtx *run_ctx, sds *err) {
|
||||
/* Process module hooks */
|
||||
moduleCallCommandFilters(c);
|
||||
|
||||
struct redisCommand *cmd = lookupCommand(c->argv, c->argc);
|
||||
struct redictCommand *cmd = lookupCommand(c->argv, c->argc);
|
||||
c->cmd = c->lastcmd = c->realcmd = cmd;
|
||||
if (scriptVerifyCommandArity(cmd, c->argc, err) != C_OK) {
|
||||
goto error;
|
||||
|
||||
@ -1121,7 +1121,7 @@ static int luaRedisAclCheckCmdPermissionsCommand(lua_State *lua) {
|
||||
if (argv == NULL) return luaError(lua);
|
||||
|
||||
/* Find command */
|
||||
struct redisCommand *cmd;
|
||||
struct redictCommand *cmd;
|
||||
if ((cmd = lookupCommand(argv, argc)) == NULL) {
|
||||
luaPushError(lua, "Invalid command passed to redis.acl_check_cmd()");
|
||||
raise_error = 1;
|
||||
|
||||
102
src/server.c
102
src/server.c
@ -67,7 +67,7 @@ double R_Zero, R_PosInf, R_NegInf, R_Nan;
|
||||
/*================================= Globals ================================= */
|
||||
|
||||
/* Global vars */
|
||||
struct redisServer server; /* Server global state */
|
||||
struct redictServer server; /* Server global state */
|
||||
|
||||
/*============================ Internal prototypes ========================== */
|
||||
|
||||
@ -2884,7 +2884,7 @@ void InitServerLast(void) {
|
||||
* because anyway the legacy (first,last,step) spec is to be deprecated
|
||||
* and one should use the new key specs scheme.
|
||||
*/
|
||||
void populateCommandLegacyRangeSpec(struct redisCommand *c) {
|
||||
void populateCommandLegacyRangeSpec(struct redictCommand *c) {
|
||||
memset(&c->legacy_range_key_spec, 0, sizeof(c->legacy_range_key_spec));
|
||||
|
||||
/* Set the movablekeys flag if we have a GETKEYS flag for modules.
|
||||
@ -2963,7 +2963,7 @@ sds catSubCommandFullname(const char *parent_name, const char *sub_name) {
|
||||
return sdscatfmt(sdsempty(), "%s|%s", parent_name, sub_name);
|
||||
}
|
||||
|
||||
void commandAddSubcommand(struct redisCommand *parent, struct redisCommand *subcommand, const char *declared_name) {
|
||||
void commandAddSubcommand(struct redictCommand *parent, struct redictCommand *subcommand, const char *declared_name) {
|
||||
if (!parent->subcommands_dict)
|
||||
parent->subcommands_dict = dictCreate(&commandTableDictType);
|
||||
|
||||
@ -2975,7 +2975,7 @@ void commandAddSubcommand(struct redisCommand *parent, struct redisCommand *subc
|
||||
|
||||
/* Set implicit ACl categories (see comment above the definition of
|
||||
* struct redisCommand). */
|
||||
void setImplicitACLCategories(struct redisCommand *c) {
|
||||
void setImplicitACLCategories(struct redictCommand *c) {
|
||||
if (c->flags & CMD_WRITE)
|
||||
c->acl_categories |= ACL_CATEGORY_WRITE;
|
||||
/* Exclude scripting commands from the RO category. */
|
||||
@ -2999,7 +2999,7 @@ void setImplicitACLCategories(struct redisCommand *c) {
|
||||
*
|
||||
* On success, the function return C_OK. Otherwise C_ERR is returned and we won't
|
||||
* add this command in the commands dict. */
|
||||
int populateCommandStructure(struct redisCommand *c) {
|
||||
int populateCommandStructure(struct redictCommand *c) {
|
||||
/* If the command marks with CMD_SENTINEL, it exists in sentinel. */
|
||||
if (!(c->flags & CMD_SENTINEL) && server.sentinel_mode)
|
||||
return C_ERR;
|
||||
@ -3025,7 +3025,7 @@ int populateCommandStructure(struct redisCommand *c) {
|
||||
/* Handle subcommands */
|
||||
if (c->subcommands) {
|
||||
for (int j = 0; c->subcommands[j].declared_name; j++) {
|
||||
struct redisCommand *sub = c->subcommands+j;
|
||||
struct redictCommand *sub = c->subcommands+j;
|
||||
|
||||
sub->fullname = catSubCommandFullname(c->declared_name, sub->declared_name);
|
||||
if (populateCommandStructure(sub) == C_ERR)
|
||||
@ -3038,16 +3038,16 @@ int populateCommandStructure(struct redisCommand *c) {
|
||||
return C_OK;
|
||||
}
|
||||
|
||||
extern struct redisCommand redisCommandTable[];
|
||||
extern struct redictCommand redictCommandTable[];
|
||||
|
||||
/* Populates the Redict Command Table dict from the static table in commands.c
|
||||
* which is auto generated from the json files in the commands folder. */
|
||||
void populateCommandTable(void) {
|
||||
int j;
|
||||
struct redisCommand *c;
|
||||
struct redictCommand *c;
|
||||
|
||||
for (j = 0;; j++) {
|
||||
c = redisCommandTable + j;
|
||||
c = redictCommandTable + j;
|
||||
if (c->declared_name == NULL)
|
||||
break;
|
||||
|
||||
@ -3066,13 +3066,13 @@ void populateCommandTable(void) {
|
||||
}
|
||||
|
||||
void resetCommandTableStats(dict* commands) {
|
||||
struct redisCommand *c;
|
||||
struct redictCommand *c;
|
||||
dictEntry *de;
|
||||
dictIterator *di;
|
||||
|
||||
di = dictGetSafeIterator(commands);
|
||||
while((de = dictNext(di)) != NULL) {
|
||||
c = (struct redisCommand *) dictGetVal(de);
|
||||
c = (struct redictCommand *) dictGetVal(de);
|
||||
c->microseconds = 0;
|
||||
c->calls = 0;
|
||||
c->rejected_calls = 0;
|
||||
@ -3134,12 +3134,12 @@ void redisOpArrayFree(redisOpArray *oa) {
|
||||
/* ====================== Commands lookup and execution ===================== */
|
||||
|
||||
int isContainerCommandBySds(sds s) {
|
||||
struct redisCommand *base_cmd = dictFetchValue(server.commands, s);
|
||||
struct redictCommand *base_cmd = dictFetchValue(server.commands, s);
|
||||
int has_subcommands = base_cmd && base_cmd->subcommands_dict;
|
||||
return has_subcommands;
|
||||
}
|
||||
|
||||
struct redisCommand *lookupSubcommand(struct redisCommand *container, sds sub_name) {
|
||||
struct redictCommand *lookupSubcommand(struct redictCommand *container, sds sub_name) {
|
||||
return dictFetchValue(container->subcommands_dict, sub_name);
|
||||
}
|
||||
|
||||
@ -3151,8 +3151,8 @@ struct redisCommand *lookupSubcommand(struct redisCommand *container, sds sub_na
|
||||
* name (e.g. in COMMAND INFO) rather than to find the command
|
||||
* a user requested to execute (in processCommand).
|
||||
*/
|
||||
struct redisCommand *lookupCommandLogic(dict *commands, robj **argv, int argc, int strict) {
|
||||
struct redisCommand *base_cmd = dictFetchValue(commands, argv[0]->ptr);
|
||||
struct redictCommand *lookupCommandLogic(dict *commands, robj **argv, int argc, int strict) {
|
||||
struct redictCommand *base_cmd = dictFetchValue(commands, argv[0]->ptr);
|
||||
int has_subcommands = base_cmd && base_cmd->subcommands_dict;
|
||||
if (argc == 1 || !has_subcommands) {
|
||||
if (strict && argc != 1)
|
||||
@ -3167,11 +3167,11 @@ struct redisCommand *lookupCommandLogic(dict *commands, robj **argv, int argc, i
|
||||
}
|
||||
}
|
||||
|
||||
struct redisCommand *lookupCommand(robj **argv, int argc) {
|
||||
struct redictCommand *lookupCommand(robj **argv, int argc) {
|
||||
return lookupCommandLogic(server.commands,argv,argc,0);
|
||||
}
|
||||
|
||||
struct redisCommand *lookupCommandBySdsLogic(dict *commands, sds s) {
|
||||
struct redictCommand *lookupCommandBySdsLogic(dict *commands, sds s) {
|
||||
int argc, j;
|
||||
sds *strings = sdssplitlen(s,sdslen(s),"|",1,&argc);
|
||||
if (strings == NULL)
|
||||
@ -3190,17 +3190,17 @@ struct redisCommand *lookupCommandBySdsLogic(dict *commands, sds s) {
|
||||
argv[j] = &objects[j];
|
||||
}
|
||||
|
||||
struct redisCommand *cmd = lookupCommandLogic(commands,argv,argc,1);
|
||||
struct redictCommand *cmd = lookupCommandLogic(commands,argv,argc,1);
|
||||
sdsfreesplitres(strings,argc);
|
||||
return cmd;
|
||||
}
|
||||
|
||||
struct redisCommand *lookupCommandBySds(sds s) {
|
||||
struct redictCommand *lookupCommandBySds(sds s) {
|
||||
return lookupCommandBySdsLogic(server.commands,s);
|
||||
}
|
||||
|
||||
struct redisCommand *lookupCommandByCStringLogic(dict *commands, const char *s) {
|
||||
struct redisCommand *cmd;
|
||||
struct redictCommand *lookupCommandByCStringLogic(dict *commands, const char *s) {
|
||||
struct redictCommand *cmd;
|
||||
sds name = sdsnew(s);
|
||||
|
||||
cmd = lookupCommandBySdsLogic(commands,name);
|
||||
@ -3208,7 +3208,7 @@ struct redisCommand *lookupCommandByCStringLogic(dict *commands, const char *s)
|
||||
return cmd;
|
||||
}
|
||||
|
||||
struct redisCommand *lookupCommandByCString(const char *s) {
|
||||
struct redictCommand *lookupCommandByCString(const char *s) {
|
||||
return lookupCommandByCStringLogic(server.commands,s);
|
||||
}
|
||||
|
||||
@ -3219,8 +3219,8 @@ struct redisCommand *lookupCommandByCString(const char *s) {
|
||||
* This is used by functions rewriting the argument vector such as
|
||||
* rewriteClientCommandVector() in order to set client->cmd pointer
|
||||
* correctly even if the command was renamed. */
|
||||
struct redisCommand *lookupCommandOrOriginal(robj **argv ,int argc) {
|
||||
struct redisCommand *cmd = lookupCommandLogic(server.commands, argv, argc, 0);
|
||||
struct redictCommand *lookupCommandOrOriginal(robj **argv ,int argc) {
|
||||
struct redictCommand *cmd = lookupCommandLogic(server.commands, argv, argc, 0);
|
||||
|
||||
if (!cmd) cmd = lookupCommandLogic(server.orig_commands, argv, argc, 0);
|
||||
return cmd;
|
||||
@ -3330,7 +3330,7 @@ void preventCommandReplication(client *c) {
|
||||
}
|
||||
|
||||
/* Log the last command a client executed into the slowlog. */
|
||||
void slowlogPushCurrentCommand(client *c, struct redisCommand *cmd, ustime_t duration) {
|
||||
void slowlogPushCurrentCommand(client *c, struct redictCommand *cmd, ustime_t duration) {
|
||||
/* Some commands may contain sensitive data that should not be available in the slowlog. */
|
||||
if (cmd->flags & CMD_SKIP_SLOWLOG)
|
||||
return;
|
||||
@ -3437,7 +3437,7 @@ void postExecutionUnitOperations(void) {
|
||||
* twice, its possible to pass a NULL cmd value to indicate that the error was counted elsewhere.
|
||||
*
|
||||
* The function returns true if stats was updated and false if not. */
|
||||
int incrCommandStatsOnError(struct redisCommand *cmd, int flags) {
|
||||
int incrCommandStatsOnError(struct redictCommand *cmd, int flags) {
|
||||
/* hold the prev error count captured on the last command execution */
|
||||
static long long prev_err_count = 0;
|
||||
int res = 0;
|
||||
@ -3494,7 +3494,7 @@ int incrCommandStatsOnError(struct redisCommand *cmd, int flags) {
|
||||
void call(client *c, int flags) {
|
||||
long long dirty;
|
||||
uint64_t client_old_flags = c->flags;
|
||||
struct redisCommand *real_cmd = c->realcmd;
|
||||
struct redictCommand *real_cmd = c->realcmd;
|
||||
client *prev_client = server.executing_client;
|
||||
server.executing_client = c;
|
||||
|
||||
@ -4224,11 +4224,11 @@ void incrementErrorCount(const char *fullerr, size_t namelen) {
|
||||
return;
|
||||
}
|
||||
|
||||
struct redisError *error = zmalloc(sizeof(*error));
|
||||
struct redictError *error = zmalloc(sizeof(*error));
|
||||
error->count = 1;
|
||||
raxInsert(server.errors,(unsigned char*)fullerr,namelen,error,NULL);
|
||||
} else {
|
||||
struct redisError *error = result;
|
||||
struct redictError *error = result;
|
||||
error->count++;
|
||||
}
|
||||
}
|
||||
@ -4618,7 +4618,7 @@ void addReplyCommandFlags(client *c, uint64_t flags, replyFlagNames *replyFlags)
|
||||
}
|
||||
}
|
||||
|
||||
void addReplyFlagsForCommand(client *c, struct redisCommand *cmd) {
|
||||
void addReplyFlagsForCommand(client *c, struct redictCommand *cmd) {
|
||||
replyFlagNames flagNames[] = {
|
||||
{CMD_WRITE, "write"},
|
||||
{CMD_READONLY, "readonly"},
|
||||
@ -4650,7 +4650,7 @@ void addReplyFlagsForCommand(client *c, struct redisCommand *cmd) {
|
||||
addReplyCommandFlags(c, cmd->flags, flagNames);
|
||||
}
|
||||
|
||||
void addReplyDocFlagsForCommand(client *c, struct redisCommand *cmd) {
|
||||
void addReplyDocFlagsForCommand(client *c, struct redictCommand *cmd) {
|
||||
replyFlagNames docFlagNames[] = {
|
||||
{CMD_DOC_DEPRECATED, "deprecated"},
|
||||
{CMD_DOC_SYSCMD, "syscmd"},
|
||||
@ -4700,7 +4700,7 @@ void addReplyFlagsForArg(client *c, uint64_t flags) {
|
||||
addReplyCommandFlags(c, flags, argFlagNames);
|
||||
}
|
||||
|
||||
void addReplyCommandArgList(client *c, struct redisCommandArg *args, int num_args) {
|
||||
void addReplyCommandArgList(client *c, struct redictCommandArg *args, int num_args) {
|
||||
addReplyArrayLen(c, num_args);
|
||||
for (int j = 0; j<num_args; j++) {
|
||||
/* Count our reply len so we don't have to use deferred reply. */
|
||||
@ -4796,7 +4796,7 @@ void addReplyJson(client *c, struct jsonObject *rs) {
|
||||
|
||||
#endif
|
||||
|
||||
void addReplyCommandHistory(client *c, struct redisCommand *cmd) {
|
||||
void addReplyCommandHistory(client *c, struct redictCommand *cmd) {
|
||||
addReplySetLen(c, cmd->num_history);
|
||||
for (int j = 0; j<cmd->num_history; j++) {
|
||||
addReplyArrayLen(c, 2);
|
||||
@ -4805,14 +4805,14 @@ void addReplyCommandHistory(client *c, struct redisCommand *cmd) {
|
||||
}
|
||||
}
|
||||
|
||||
void addReplyCommandTips(client *c, struct redisCommand *cmd) {
|
||||
void addReplyCommandTips(client *c, struct redictCommand *cmd) {
|
||||
addReplySetLen(c, cmd->num_tips);
|
||||
for (int j = 0; j<cmd->num_tips; j++) {
|
||||
addReplyBulkCString(c, cmd->tips[j]);
|
||||
}
|
||||
}
|
||||
|
||||
void addReplyCommandKeySpecs(client *c, struct redisCommand *cmd) {
|
||||
void addReplyCommandKeySpecs(client *c, struct redictCommand *cmd) {
|
||||
addReplySetLen(c, cmd->key_specs_num);
|
||||
for (int i = 0; i < cmd->key_specs_num; i++) {
|
||||
int maplen = 3;
|
||||
@ -4909,7 +4909,7 @@ void addReplyCommandKeySpecs(client *c, struct redisCommand *cmd) {
|
||||
}
|
||||
|
||||
/* Reply with an array of sub-command using the provided reply callback. */
|
||||
void addReplyCommandSubCommands(client *c, struct redisCommand *cmd, void (*reply_function)(client*, struct redisCommand*), int use_map) {
|
||||
void addReplyCommandSubCommands(client *c, struct redictCommand *cmd, void (*reply_function)(client*, struct redictCommand*), int use_map) {
|
||||
if (!cmd->subcommands_dict) {
|
||||
addReplySetLen(c, 0);
|
||||
return;
|
||||
@ -4922,7 +4922,7 @@ void addReplyCommandSubCommands(client *c, struct redisCommand *cmd, void (*repl
|
||||
dictEntry *de;
|
||||
dictIterator *di = dictGetSafeIterator(cmd->subcommands_dict);
|
||||
while((de = dictNext(di)) != NULL) {
|
||||
struct redisCommand *sub = (struct redisCommand *)dictGetVal(de);
|
||||
struct redictCommand *sub = (struct redictCommand *)dictGetVal(de);
|
||||
if (use_map)
|
||||
addReplyBulkCBuffer(c, sub->fullname, sdslen(sub->fullname));
|
||||
reply_function(c, sub);
|
||||
@ -4931,7 +4931,7 @@ void addReplyCommandSubCommands(client *c, struct redisCommand *cmd, void (*repl
|
||||
}
|
||||
|
||||
/* Output the representation of a Redict command. Used by the COMMAND command and COMMAND INFO. */
|
||||
void addReplyCommandInfo(client *c, struct redisCommand *cmd) {
|
||||
void addReplyCommandInfo(client *c, struct redictCommand *cmd) {
|
||||
if (!cmd) {
|
||||
addReplyNull(c);
|
||||
} else {
|
||||
@ -4959,7 +4959,7 @@ void addReplyCommandInfo(client *c, struct redisCommand *cmd) {
|
||||
}
|
||||
|
||||
/* Output the representation of a Redict command. Used by the COMMAND DOCS. */
|
||||
void addReplyCommandDocs(client *c, struct redisCommand *cmd) {
|
||||
void addReplyCommandDocs(client *c, struct redictCommand *cmd) {
|
||||
/* Count our reply len so we don't have to use deferred reply. */
|
||||
long maplen = 1;
|
||||
if (cmd->summary) maplen++;
|
||||
@ -5032,7 +5032,7 @@ void addReplyCommandDocs(client *c, struct redisCommand *cmd) {
|
||||
|
||||
/* Helper for COMMAND GETKEYS and GETKEYSANDFLAGS */
|
||||
void getKeysSubcommandImpl(client *c, int with_flags) {
|
||||
struct redisCommand *cmd = lookupCommand(c->argv+2,c->argc-2);
|
||||
struct redictCommand *cmd = lookupCommand(c->argv+2,c->argc-2);
|
||||
getKeysResult result = GETKEYS_RESULT_INIT;
|
||||
int j;
|
||||
|
||||
@ -5116,7 +5116,7 @@ typedef struct {
|
||||
} cache;
|
||||
} commandListFilter;
|
||||
|
||||
int shouldFilterFromCommandList(struct redisCommand *cmd, commandListFilter *filter) {
|
||||
int shouldFilterFromCommandList(struct redictCommand *cmd, commandListFilter *filter) {
|
||||
switch (filter->type) {
|
||||
case (COMMAND_LIST_FILTER_MODULE):
|
||||
if (!filter->cache.valid) {
|
||||
@ -5148,7 +5148,7 @@ void commandListWithFilter(client *c, dict *commands, commandListFilter filter,
|
||||
dictIterator *di = dictGetIterator(commands);
|
||||
|
||||
while ((de = dictNext(di)) != NULL) {
|
||||
struct redisCommand *cmd = dictGetVal(de);
|
||||
struct redictCommand *cmd = dictGetVal(de);
|
||||
if (!shouldFilterFromCommandList(cmd,&filter)) {
|
||||
addReplyBulkCBuffer(c, cmd->fullname, sdslen(cmd->fullname));
|
||||
(*numcmds)++;
|
||||
@ -5167,7 +5167,7 @@ void commandListWithoutFilter(client *c, dict *commands, int *numcmds) {
|
||||
dictIterator *di = dictGetIterator(commands);
|
||||
|
||||
while ((de = dictNext(di)) != NULL) {
|
||||
struct redisCommand *cmd = dictGetVal(de);
|
||||
struct redictCommand *cmd = dictGetVal(de);
|
||||
addReplyBulkCBuffer(c, cmd->fullname, sdslen(cmd->fullname));
|
||||
(*numcmds)++;
|
||||
|
||||
@ -5251,7 +5251,7 @@ void commandDocsCommand(client *c) {
|
||||
addReplyMapLen(c, dictSize(server.commands));
|
||||
di = dictGetIterator(server.commands);
|
||||
while ((de = dictNext(di)) != NULL) {
|
||||
struct redisCommand *cmd = dictGetVal(de);
|
||||
struct redictCommand *cmd = dictGetVal(de);
|
||||
addReplyBulkCBuffer(c, cmd->fullname, sdslen(cmd->fullname));
|
||||
addReplyCommandDocs(c, cmd);
|
||||
}
|
||||
@ -5261,7 +5261,7 @@ void commandDocsCommand(client *c) {
|
||||
int numcmds = 0;
|
||||
void *replylen = addReplyDeferredLen(c);
|
||||
for (i = 2; i < c->argc; i++) {
|
||||
struct redisCommand *cmd = lookupCommandBySds(c->argv[i]->ptr);
|
||||
struct redictCommand *cmd = lookupCommandBySds(c->argv[i]->ptr);
|
||||
if (!cmd)
|
||||
continue;
|
||||
addReplyBulkCBuffer(c, cmd->fullname, sdslen(cmd->fullname));
|
||||
@ -5383,13 +5383,13 @@ const char *getSafeInfoString(const char *s, size_t len, char **tmp) {
|
||||
}
|
||||
|
||||
sds genRedisInfoStringCommandStats(sds info, dict *commands) {
|
||||
struct redisCommand *c;
|
||||
struct redictCommand *c;
|
||||
dictEntry *de;
|
||||
dictIterator *di;
|
||||
di = dictGetSafeIterator(commands);
|
||||
while((de = dictNext(di)) != NULL) {
|
||||
char *tmpsafe;
|
||||
c = (struct redisCommand *) dictGetVal(de);
|
||||
c = (struct redictCommand *) dictGetVal(de);
|
||||
if (c->calls || c->failed_calls || c->rejected_calls) {
|
||||
info = sdscatprintf(info,
|
||||
"cmdstat_%s:calls=%lld,usec=%lld,usec_per_call=%.2f"
|
||||
@ -5423,13 +5423,13 @@ sds genRedisInfoStringACLStats(sds info) {
|
||||
}
|
||||
|
||||
sds genRedisInfoStringLatencyStats(sds info, dict *commands) {
|
||||
struct redisCommand *c;
|
||||
struct redictCommand *c;
|
||||
dictEntry *de;
|
||||
dictIterator *di;
|
||||
di = dictGetSafeIterator(commands);
|
||||
while((de = dictNext(di)) != NULL) {
|
||||
char *tmpsafe;
|
||||
c = (struct redisCommand *) dictGetVal(de);
|
||||
c = (struct redictCommand *) dictGetVal(de);
|
||||
if (c->latency_histogram) {
|
||||
info = fillPercentileDistributionLatencies(info,
|
||||
getSafeInfoString(c->fullname, sdslen(c->fullname), &tmpsafe),
|
||||
@ -6049,10 +6049,10 @@ sds genRedisInfoString(dict *section_dict, int all_sections, int everything) {
|
||||
raxIterator ri;
|
||||
raxStart(&ri,server.errors);
|
||||
raxSeek(&ri,"^",NULL,0);
|
||||
struct redisError *e;
|
||||
struct redictError *e;
|
||||
while(raxNext(&ri)) {
|
||||
char *tmpsafe;
|
||||
e = (struct redisError *) ri.data;
|
||||
e = (struct redictError *) ri.data;
|
||||
info = sdscatprintf(info,
|
||||
"errorstat_%.*s:count=%lld\r\n",
|
||||
(int)ri.key_len, getSafeInfoString((char *) ri.key, ri.key_len, &tmpsafe), e->count);
|
||||
|
||||
126
src/server.h
126
src/server.h
@ -717,7 +717,7 @@ struct RedisModuleDigest;
|
||||
struct RedisModuleCtx;
|
||||
struct moduleLoadQueueEntry;
|
||||
struct RedisModuleKeyOptCtx;
|
||||
struct RedisModuleCommand;
|
||||
struct RedictModuleCommand;
|
||||
struct clusterState;
|
||||
|
||||
/* Each module type implementation should export a set of methods in order
|
||||
@ -985,7 +985,7 @@ typedef struct multiCmd {
|
||||
robj **argv;
|
||||
int argv_len;
|
||||
int argc;
|
||||
struct redisCommand *cmd;
|
||||
struct redictCommand *cmd;
|
||||
} multiCmd;
|
||||
|
||||
typedef struct multiState {
|
||||
@ -1155,8 +1155,8 @@ typedef struct client {
|
||||
int original_argc; /* Num of arguments of original command if arguments were rewritten. */
|
||||
robj **original_argv; /* Arguments of original command if arguments were rewritten. */
|
||||
size_t argv_len_sum; /* Sum of lengths of objects in argv list. */
|
||||
struct redisCommand *cmd, *lastcmd; /* Last command executed. */
|
||||
struct redisCommand *realcmd; /* The original command that was executed by the client,
|
||||
struct redictCommand *cmd, *lastcmd; /* Last command executed. */
|
||||
struct redictCommand *realcmd; /* The original command that was executed by the client,
|
||||
Used to update error stats in case the c->cmd was modified
|
||||
during the command invocation (like on GEOADD for example). */
|
||||
user *user; /* User associated with this connection. If the
|
||||
@ -1522,7 +1522,7 @@ typedef enum childInfoType {
|
||||
CHILD_INFO_TYPE_MODULE_COW_SIZE
|
||||
} childInfoType;
|
||||
|
||||
struct redisServer {
|
||||
struct redictServer {
|
||||
/* General */
|
||||
pid_t pid; /* Main process pid. */
|
||||
pthread_t main_thread_id; /* Main thread id */
|
||||
@ -2213,10 +2213,10 @@ typedef enum {
|
||||
COMMAND_GROUP_STREAM,
|
||||
COMMAND_GROUP_BITMAP,
|
||||
COMMAND_GROUP_MODULE,
|
||||
} redisCommandGroup;
|
||||
} redictCommandGroup;
|
||||
|
||||
typedef void redisCommandProc(client *c);
|
||||
typedef int redisGetKeysProc(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
typedef void redictCommandProc(client *c);
|
||||
typedef int redictGetKeysProc(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
|
||||
/* Redis command structure.
|
||||
*
|
||||
@ -2311,7 +2311,7 @@ typedef int redisGetKeysProc(struct redisCommand *cmd, robj **argv, int argc, ge
|
||||
* specific data structures, such as: DEL, RENAME, MOVE, SELECT,
|
||||
* TYPE, EXPIRE*, PEXPIRE*, TTL, PTTL, ...
|
||||
*/
|
||||
struct redisCommand {
|
||||
struct redictCommand {
|
||||
/* Declarative data */
|
||||
const char *declared_name; /* A string representing the command declared_name.
|
||||
* It is a const char * for native commands and SDS for module commands. */
|
||||
@ -2321,12 +2321,12 @@ struct redisCommand {
|
||||
int doc_flags; /* Flags for documentation (see CMD_DOC_*). */
|
||||
const char *replaced_by; /* In case the command is deprecated, this is the successor command. */
|
||||
const char *deprecated_since; /* In case the command is deprecated, when did it happen? */
|
||||
redisCommandGroup group; /* Command group */
|
||||
redictCommandGroup group; /* Command group */
|
||||
commandHistory *history; /* History of the command */
|
||||
int num_history;
|
||||
const char **tips; /* An array of strings that are meant to be tips for clients/proxies regarding this command */
|
||||
int num_tips;
|
||||
redisCommandProc *proc; /* Command implementation */
|
||||
redictCommandProc *proc; /* Command implementation */
|
||||
int arity; /* Number of arguments, it is possible to use -N to say >= N */
|
||||
uint64_t flags; /* Command flags, see CMD_*. */
|
||||
uint64_t acl_categories; /* ACl categories, see ACL_CATEGORY_*. */
|
||||
@ -2334,12 +2334,12 @@ struct redisCommand {
|
||||
int key_specs_num;
|
||||
/* Use a function to determine keys arguments in a command line.
|
||||
* Used for Redis Cluster redirect (may be NULL) */
|
||||
redisGetKeysProc *getkeys_proc;
|
||||
redictGetKeysProc *getkeys_proc;
|
||||
int num_args; /* Length of args array. */
|
||||
/* Array of subcommands (may be NULL) */
|
||||
struct redisCommand *subcommands;
|
||||
struct redictCommand *subcommands;
|
||||
/* Array of arguments (may be NULL) */
|
||||
struct redisCommandArg *args;
|
||||
struct redictCommandArg *args;
|
||||
#ifdef LOG_REQ_RES
|
||||
/* Reply schema */
|
||||
struct jsonObject *reply_schema;
|
||||
@ -2360,31 +2360,31 @@ struct redisCommand {
|
||||
* COMMAND INFO and COMMAND GETKEYS */
|
||||
dict *subcommands_dict; /* A dictionary that holds the subcommands, the key is the subcommand sds name
|
||||
* (not the fullname), and the value is the redisCommand structure pointer. */
|
||||
struct redisCommand *parent;
|
||||
struct RedisModuleCommand *module_cmd; /* A pointer to the module command data (NULL if native command) */
|
||||
struct redictCommand *parent;
|
||||
struct RedictModuleCommand *module_cmd; /* A pointer to the module command data (NULL if native command) */
|
||||
};
|
||||
|
||||
struct redisError {
|
||||
struct redictError {
|
||||
long long count;
|
||||
};
|
||||
|
||||
struct redisFunctionSym {
|
||||
struct redictFunctionSym {
|
||||
char *name;
|
||||
unsigned long pointer;
|
||||
};
|
||||
|
||||
typedef struct _redisSortObject {
|
||||
typedef struct _redictSortObject {
|
||||
robj *obj;
|
||||
union {
|
||||
double score;
|
||||
robj *cmpobj;
|
||||
} u;
|
||||
} redisSortObject;
|
||||
} redictSortObject;
|
||||
|
||||
typedef struct _redisSortOperation {
|
||||
typedef struct _redictSortOperation {
|
||||
int type;
|
||||
robj *pattern;
|
||||
} redisSortOperation;
|
||||
} redictSortOperation;
|
||||
|
||||
/* Structure to hold list iteration abstraction. */
|
||||
typedef struct {
|
||||
@ -2440,7 +2440,7 @@ extern int io_threads_op;
|
||||
* Extern declarations
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
extern struct redisServer server;
|
||||
extern struct redictServer server;
|
||||
extern struct sharedObjectsStruct shared;
|
||||
extern dictType objectKeyPointerValueDictType;
|
||||
extern dictType objectKeyHeapPointerValueDictType;
|
||||
@ -2466,7 +2466,7 @@ extern dict *modules;
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
/* Command metadata */
|
||||
void populateCommandLegacyRangeSpec(struct redisCommand *c);
|
||||
void populateCommandLegacyRangeSpec(struct redictCommand *c);
|
||||
|
||||
/* Modules */
|
||||
void moduleInitModulesSystem(void);
|
||||
@ -2475,14 +2475,14 @@ void modulesCron(void);
|
||||
int moduleLoad(const char *path, void **argv, int argc, int is_loadex);
|
||||
int moduleUnload(sds name, const char **errmsg);
|
||||
void moduleLoadFromQueue(void);
|
||||
int moduleGetCommandKeysViaAPI(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int moduleGetCommandChannelsViaAPI(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int moduleGetCommandKeysViaAPI(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int moduleGetCommandChannelsViaAPI(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
moduleType *moduleTypeLookupModuleByID(uint64_t id);
|
||||
moduleType *moduleTypeLookupModuleByName(const char *name);
|
||||
moduleType *moduleTypeLookupModuleByNameIgnoreCase(const char *name);
|
||||
void moduleTypeNameByID(char *name, uint64_t moduleid);
|
||||
const char *moduleTypeModuleName(moduleType *mt);
|
||||
const char *moduleNameFromCommand(struct redisCommand *cmd);
|
||||
const char *moduleNameFromCommand(struct redictCommand *cmd);
|
||||
void moduleFreeContext(struct RedisModuleCtx *ctx);
|
||||
void moduleCallCommandUnblockedHandler(client *c);
|
||||
int isModuleClientUnblocked(client *c);
|
||||
@ -2519,7 +2519,7 @@ int moduleDefragValue(robj *key, robj *obj, int dbid);
|
||||
int moduleLateDefrag(robj *key, robj *value, unsigned long *cursor, long long endtime, int dbid);
|
||||
void moduleDefragGlobals(void);
|
||||
void *moduleGetHandleByName(char *modulename);
|
||||
int moduleIsModuleCommand(void *module_handle, struct redisCommand *cmd);
|
||||
int moduleIsModuleCommand(void *module_handle, struct redictCommand *cmd);
|
||||
|
||||
/* Utils */
|
||||
long long ustime(void);
|
||||
@ -2928,8 +2928,8 @@ void ACLClearCommandID(void);
|
||||
user *ACLGetUserByName(const char *name, size_t namelen);
|
||||
int ACLUserCheckKeyPerm(user *u, const char *key, int keylen, int flags);
|
||||
int ACLUserCheckChannelPerm(user *u, sds channel, int literal);
|
||||
int ACLCheckAllUserCommandPerm(user *u, struct redisCommand *cmd, robj **argv, int argc, int *idxptr);
|
||||
int ACLUserCheckCmdWithUnrestrictedKeyAccess(user *u, struct redisCommand *cmd, robj **argv, int argc, int flags);
|
||||
int ACLCheckAllUserCommandPerm(user *u, struct redictCommand *cmd, robj **argv, int argc, int *idxptr);
|
||||
int ACLUserCheckCmdWithUnrestrictedKeyAccess(user *u, struct redictCommand *cmd, robj **argv, int argc, int flags);
|
||||
int ACLCheckAllPerm(client *c, int *idxptr);
|
||||
int ACLSetUser(user *u, const char *op, ssize_t oplen);
|
||||
sds ACLStringSetUser(user *u, sds username, sds *argv, int argc);
|
||||
@ -2941,11 +2941,11 @@ const char *ACLSetUserStringError(void);
|
||||
int ACLLoadConfiguredUsers(void);
|
||||
robj *ACLDescribeUser(user *u);
|
||||
void ACLLoadUsersAtStartup(void);
|
||||
void addReplyCommandCategories(client *c, struct redisCommand *cmd);
|
||||
void addReplyCommandCategories(client *c, struct redictCommand *cmd);
|
||||
user *ACLCreateUnlinkedUser(void);
|
||||
void ACLFreeUserAndKillClients(user *u);
|
||||
void addACLLogEntry(client *c, int reason, int context, int argpos, sds username, sds object);
|
||||
sds getAclErrorMessage(int acl_res, user *user, struct redisCommand *cmd, sds errored_val, int verbose);
|
||||
sds getAclErrorMessage(int acl_res, user *user, struct redictCommand *cmd, sds errored_val, int verbose);
|
||||
void ACLUpdateDefaultUserPassword(sds password);
|
||||
sds genRedisInfoStringACLStats(sds info);
|
||||
void ACLRecomputeCommandBitsFromCommandRulesAllUsers(void);
|
||||
@ -3029,17 +3029,17 @@ int createSocketAcceptHandler(connListener *sfd, aeFileProc *accept_handler);
|
||||
connListener *listenerByType(const char *typename);
|
||||
int changeListener(connListener *listener);
|
||||
void closeListener(connListener *listener);
|
||||
struct redisCommand *lookupSubcommand(struct redisCommand *container, sds sub_name);
|
||||
struct redisCommand *lookupCommand(robj **argv, int argc);
|
||||
struct redisCommand *lookupCommandBySdsLogic(dict *commands, sds s);
|
||||
struct redisCommand *lookupCommandBySds(sds s);
|
||||
struct redisCommand *lookupCommandByCStringLogic(dict *commands, const char *s);
|
||||
struct redisCommand *lookupCommandByCString(const char *s);
|
||||
struct redisCommand *lookupCommandOrOriginal(robj **argv, int argc);
|
||||
struct redictCommand *lookupSubcommand(struct redictCommand *container, sds sub_name);
|
||||
struct redictCommand *lookupCommand(robj **argv, int argc);
|
||||
struct redictCommand *lookupCommandBySdsLogic(dict *commands, sds s);
|
||||
struct redictCommand *lookupCommandBySds(sds s);
|
||||
struct redictCommand *lookupCommandByCStringLogic(dict *commands, const char *s);
|
||||
struct redictCommand *lookupCommandByCString(const char *s);
|
||||
struct redictCommand *lookupCommandOrOriginal(robj **argv, int argc);
|
||||
int commandCheckExistence(client *c, sds *err);
|
||||
int commandCheckArity(client *c, sds *err);
|
||||
void startCommandExecution(void);
|
||||
int incrCommandStatsOnError(struct redisCommand *cmd, int flags);
|
||||
int incrCommandStatsOnError(struct redictCommand *cmd, int flags);
|
||||
void call(client *c, int flags);
|
||||
void alsoPropagate(int dbid, robj **argv, int argc, int target);
|
||||
void postExecutionUnitOperations(void);
|
||||
@ -3048,7 +3048,7 @@ void forceCommandPropagation(client *c, int flags);
|
||||
void preventCommandPropagation(client *c);
|
||||
void preventCommandAOF(client *c);
|
||||
void preventCommandReplication(client *c);
|
||||
void slowlogPushCurrentCommand(client *c, struct redisCommand *cmd, ustime_t duration);
|
||||
void slowlogPushCurrentCommand(client *c, struct redictCommand *cmd, ustime_t duration);
|
||||
void updateCommandLatencyHistogram(struct hdr_histogram** latency_histogram, int64_t duration_hist);
|
||||
int prepareForShutdown(int flags);
|
||||
void replyToClientsBlockedOnShutdown(void);
|
||||
@ -3315,29 +3315,29 @@ void freeReplicationBacklogRefMemAsync(list *blocks, rax *index);
|
||||
#define GET_KEYSPEC_INCLUDE_NOT_KEYS (1<<0) /* Consider 'fake' keys as keys */
|
||||
#define GET_KEYSPEC_RETURN_PARTIAL (1<<1) /* Return all keys that can be found */
|
||||
|
||||
int getKeysFromCommandWithSpecs(struct redisCommand *cmd, robj **argv, int argc, int search_flags, getKeysResult *result);
|
||||
int getKeysFromCommandWithSpecs(struct redictCommand *cmd, robj **argv, int argc, int search_flags, getKeysResult *result);
|
||||
keyReference *getKeysPrepareResult(getKeysResult *result, int numkeys);
|
||||
int getKeysFromCommand(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int doesCommandHaveKeys(struct redisCommand *cmd);
|
||||
int getChannelsFromCommand(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int doesCommandHaveChannelsWithFlags(struct redisCommand *cmd, int flags);
|
||||
int getKeysFromCommand(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int doesCommandHaveKeys(struct redictCommand *cmd);
|
||||
int getChannelsFromCommand(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int doesCommandHaveChannelsWithFlags(struct redictCommand *cmd, int flags);
|
||||
void getKeysFreeResult(getKeysResult *result);
|
||||
int sintercardGetKeys(struct redisCommand *cmd,robj **argv, int argc, getKeysResult *result);
|
||||
int zunionInterDiffGetKeys(struct redisCommand *cmd,robj **argv, int argc, getKeysResult *result);
|
||||
int zunionInterDiffStoreGetKeys(struct redisCommand *cmd,robj **argv, int argc, getKeysResult *result);
|
||||
int evalGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int functionGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int sortGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int sortROGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int migrateGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int georadiusGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int xreadGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int lmpopGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int blmpopGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int zmpopGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int bzmpopGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int setGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int bitfieldGetKeys(struct redisCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int sintercardGetKeys(struct redictCommand *cmd,robj **argv, int argc, getKeysResult *result);
|
||||
int zunionInterDiffGetKeys(struct redictCommand *cmd,robj **argv, int argc, getKeysResult *result);
|
||||
int zunionInterDiffStoreGetKeys(struct redictCommand *cmd,robj **argv, int argc, getKeysResult *result);
|
||||
int evalGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int functionGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int sortGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int sortROGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int migrateGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int georadiusGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int xreadGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int lmpopGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int blmpopGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int zmpopGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int bzmpopGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int setGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
int bitfieldGetKeys(struct redictCommand *cmd, robj **argv, int argc, getKeysResult *result);
|
||||
|
||||
unsigned short crc16(const char *buf, int len);
|
||||
|
||||
@ -3744,7 +3744,7 @@ int memtest_preserving_test(unsigned long *m, size_t bytes, int passes);
|
||||
void mixDigest(unsigned char *digest, const void *ptr, size_t len);
|
||||
void xorDigest(unsigned char *digest, const void *ptr, size_t len);
|
||||
sds catSubCommandFullname(const char *parent_name, const char *sub_name);
|
||||
void commandAddSubcommand(struct redisCommand *parent, struct redisCommand *subcommand, const char *declared_name);
|
||||
void commandAddSubcommand(struct redictCommand *parent, struct redictCommand *subcommand, const char *declared_name);
|
||||
void debugDelay(int usec);
|
||||
void killIOThreads(void);
|
||||
void killThreads(void);
|
||||
|
||||
18
src/sort.c
18
src/sort.c
@ -12,8 +12,8 @@
|
||||
|
||||
zskiplistNode* zslGetElementByRank(zskiplist *zsl, unsigned long rank);
|
||||
|
||||
redisSortOperation *createSortOperation(int type, robj *pattern) {
|
||||
redisSortOperation *so = zmalloc(sizeof(*so));
|
||||
redictSortOperation *createSortOperation(int type, robj *pattern) {
|
||||
redictSortOperation *so = zmalloc(sizeof(*so));
|
||||
so->type = type;
|
||||
so->pattern = pattern;
|
||||
return so;
|
||||
@ -113,7 +113,7 @@ noobj:
|
||||
* the additional parameter is not standard but a BSD-specific we have to
|
||||
* pass sorting parameters via the global 'server' structure */
|
||||
int sortCompare(const void *s1, const void *s2) {
|
||||
const redisSortObject *so1 = s1, *so2 = s2;
|
||||
const redictSortObject *so1 = s1, *so2 = s2;
|
||||
int cmp;
|
||||
|
||||
if (!server.sort_alpha) {
|
||||
@ -173,7 +173,7 @@ void sortCommandGeneric(client *c, int readonly) {
|
||||
int int_conversion_error = 0;
|
||||
int syntax_error = 0;
|
||||
robj *sortval, *sortby = NULL, *storekey = NULL;
|
||||
redisSortObject *vector; /* Resulting vector to sort */
|
||||
redictSortObject *vector; /* Resulting vector to sort */
|
||||
int user_has_full_key_access = 0; /* ACL - used in order to verify 'get' and 'by' options can be used */
|
||||
/* Create a list of operations to perform for every sorted element.
|
||||
* Operations can be GET */
|
||||
@ -339,7 +339,7 @@ void sortCommandGeneric(client *c, int readonly) {
|
||||
}
|
||||
|
||||
/* Load the sorting vector with all the objects to sort */
|
||||
vector = zmalloc(sizeof(redisSortObject)*vectorlen);
|
||||
vector = zmalloc(sizeof(redictSortObject)*vectorlen);
|
||||
j = 0;
|
||||
|
||||
if (sortval->type == OBJ_LIST && dontsort) {
|
||||
@ -492,9 +492,9 @@ void sortCommandGeneric(client *c, int readonly) {
|
||||
server.sort_bypattern = sortby ? 1 : 0;
|
||||
server.sort_store = storekey ? 1 : 0;
|
||||
if (sortby && (start != 0 || end != vectorlen-1))
|
||||
pqsort(vector,vectorlen,sizeof(redisSortObject),sortCompare, start,end);
|
||||
pqsort(vector,vectorlen,sizeof(redictSortObject),sortCompare, start,end);
|
||||
else
|
||||
qsort(vector,vectorlen,sizeof(redisSortObject),sortCompare);
|
||||
qsort(vector,vectorlen,sizeof(redictSortObject),sortCompare);
|
||||
}
|
||||
|
||||
/* Send command output to the output buffer, performing the specified
|
||||
@ -512,7 +512,7 @@ void sortCommandGeneric(client *c, int readonly) {
|
||||
if (!getop) addReplyBulk(c,vector[j].obj);
|
||||
listRewind(operations,&li);
|
||||
while((ln = listNext(&li))) {
|
||||
redisSortOperation *sop = ln->value;
|
||||
redictSortOperation *sop = ln->value;
|
||||
robj *val = lookupKeyByPattern(c->db,sop->pattern,
|
||||
vector[j].obj);
|
||||
|
||||
@ -544,7 +544,7 @@ void sortCommandGeneric(client *c, int readonly) {
|
||||
} else {
|
||||
listRewind(operations,&li);
|
||||
while((ln = listNext(&li))) {
|
||||
redisSortOperation *sop = ln->value;
|
||||
redictSortOperation *sop = ln->value;
|
||||
robj *val = lookupKeyByPattern(c->db,sop->pattern,
|
||||
vector[j].obj);
|
||||
|
||||
|
||||
@ -583,9 +583,9 @@ with open("%s/%s.def" % (srcdir, commands_filename), "w") as f:
|
||||
"""
|
||||
/* We have fabulous commands from
|
||||
* the fantastic
|
||||
* Redis Command Table! */
|
||||
* Redict Command Table! */
|
||||
|
||||
/* Must match redisCommandGroup */
|
||||
/* Must match redictCommandGroup */
|
||||
const char *COMMAND_GROUP_STR[] = {
|
||||
"generic",
|
||||
"string",
|
||||
@ -618,7 +618,7 @@ const char *commandGroupStr(int index) {
|
||||
command.write_internal_structs(f)
|
||||
|
||||
f.write("/* Main command table */\n")
|
||||
f.write("struct COMMAND_STRUCT redisCommandTable[] = {\n")
|
||||
f.write("struct COMMAND_STRUCT redictCommandTable[] = {\n")
|
||||
curr_group = None
|
||||
for command in command_list:
|
||||
if curr_group != command.group:
|
||||
|
||||
Loading…
Reference in New Issue
Block a user