void SpellCheck_SendReplyOnTerm(RedisModuleCtx *ctx, char *term, size_t len, RS_Suggestions *s,
uint64_t totalDocNumber) {
#define TERM "TERM"
RedisModule_ReplyWithArray(ctx, 3);
RedisModule_ReplyWithStringBuffer(ctx, TERM, strlen(TERM));
RedisModule_ReplyWithStringBuffer(ctx, term, len);
RS_Suggestion **suggestions = spellCheck_GetSuggestions(s);
for (int i = 0; i < array_len(suggestions); ++i) {
if (suggestions[i]->score == -1) {
suggestions[i]->score = 0;
} else {
if (totalDocNumber > 0) {
suggestions[i]->score = (suggestions[i]->score) / totalDocNumber;
}
}
}
qsort(suggestions, array_len(suggestions), sizeof(RS_Suggestion *), RS_SuggestionCompare);
if (array_len(suggestions) == 0) {
// no results found, we return an empty array
RedisModule_ReplyWithArray(ctx, 0);
} else {
RedisModule_ReplyWithArray(ctx, array_len(suggestions));
for (int i = 0; i < array_len(suggestions); ++i) {
RedisModule_ReplyWithArray(ctx, 2);
RedisModule_ReplyWithDouble(ctx, suggestions[i]->score);
RedisModule_ReplyWithStringBuffer(ctx, suggestions[i]->suggestion, suggestions[i]->len);
}
}
array_free_ex(suggestions, RS_SuggestionFree(*(RS_Suggestion **)ptr));
}
/* HELLOTYPE.RANGE key first count */
int HelloTypeRange_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
RedisModule_AutoMemory(ctx); /* Use automatic memory management. */
if (argc != 4) return RedisModule_WrongArity(ctx);
RedisModuleKey *key = RedisModule_OpenKey(ctx,argv[1],
REDISMODULE_READ|REDISMODULE_WRITE);
int type = RedisModule_KeyType(key);
if (type != REDISMODULE_KEYTYPE_EMPTY &&
RedisModule_ModuleTypeGetType(key) != HelloType)
{
return RedisModule_ReplyWithError(ctx,REDISMODULE_ERRORMSG_WRONGTYPE);
}
long long first, count;
if (RedisModule_StringToLongLong(argv[2],&first) != REDISMODULE_OK ||
RedisModule_StringToLongLong(argv[3],&count) != REDISMODULE_OK ||
first < 0 || count < 0)
{
return RedisModule_ReplyWithError(ctx,
"ERR invalid first or count parameters");
}
struct HelloTypeObject *hto = RedisModule_ModuleTypeGetValue(key);
struct HelloTypeNode *node = hto ? hto->head : NULL;
RedisModule_ReplyWithArray(ctx,REDISMODULE_POSTPONED_ARRAY_LEN);
long long arraylen = 0;
while(node && count--) {
RedisModule_ReplyWithLongLong(ctx,node->value);
arraylen++;
node = node->next;
}
RedisModule_ReplySetArrayLength(ctx,arraylen);
return REDISMODULE_OK;
}
int UniqueGetAllCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
if (argc != 2) {
return RedisModule_WrongArity(ctx);
}
RedisModule_AutoMemory(ctx);
// open the key and make sure it is indeed a Hash and not empty
RedisModuleKey *key =
RedisModule_OpenKey(ctx, argv[1], REDISMODULE_READ);
int type = RedisModule_KeyType(key);
if (type == REDISMODULE_KEYTYPE_EMPTY) {
RedisModule_ReplyWithNull(ctx);
return REDISMODULE_OK;
}
if (RedisModule_ModuleTypeGetType(key) != UniqueType) {
return RedisModule_ReplyWithError(ctx,REDISMODULE_ERRORMSG_WRONGTYPE);
}
unique *unique = RedisModule_ModuleTypeGetValue(key);
size_t len = uniqueLen(unique);
RedisModule_ReplyWithArray(ctx, len*2);
size_t i;
listIter *it = listGetIterator(unique->l, AL_START_HEAD);
listNode *node;
for (node = listNext(it), i=0; node && i<len; node = listNext(it),i++) {
dictEntry *en = node->value;
RedisModule_ReplyWithStringBuffer(ctx, en->key, sdslen(en->key));
RedisModule_ReplyWithStringBuffer(ctx, en->v.val, sdslen(en->v.val));
}
return REDISMODULE_OK;
}
/* HELLO.LEXRANGE key min_lex max_lex min_age max_age
* This command expects a sorted set stored at key in the following form:
* - All the elements have score 0.
* - Elements are pairs of "<name>:<age>", for example "Anna:52".
* The command will return all the sorted set items that are lexicographically
* between the specified range (using the same format as ZRANGEBYLEX)
* and having an age between min_age and max_age. */
int HelloLexRange_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
RedisModule_AutoMemory(ctx); /* Use automatic memory management. */
if (argc != 6) return RedisModule_WrongArity(ctx);
RedisModuleKey *key = RedisModule_OpenKey(ctx,argv[1],
REDISMODULE_READ|REDISMODULE_WRITE);
if (RedisModule_KeyType(key) != REDISMODULE_KEYTYPE_ZSET) {
return RedisModule_ReplyWithError(ctx,REDISMODULE_ERRORMSG_WRONGTYPE);
}
if (RedisModule_ZsetFirstInLexRange(key,argv[2],argv[3]) != REDISMODULE_OK) {
return RedisModule_ReplyWithError(ctx,"invalid range");
}
int arraylen = 0;
RedisModule_ReplyWithArray(ctx,REDISMODULE_POSTPONED_ARRAY_LEN);
while(!RedisModule_ZsetRangeEndReached(key)) {
double score;
RedisModuleString *ele = RedisModule_ZsetRangeCurrentElement(key,&score);
RedisModule_ReplyWithString(ctx,ele);
RedisModule_FreeString(ctx,ele);
RedisModule_ZsetRangeNext(key);
arraylen++;
}
RedisModule_ZsetRangeStop(key);
RedisModule_ReplySetArrayLength(ctx,arraylen);
RedisModule_CloseKey(key);
return REDISMODULE_OK;
}
static void PopReplyFV(RedisModuleCtx *ctx, sds skey, sds sval) {
int i, n = sdslen(sval)/8;
RedisModule_ReplyWithArray(ctx, 1+n);
RedisModule_ReplyWithStringBuffer(ctx, skey, sdslen(skey));
long long *pvec = (long long*)sval;
for (i=0; i<n; i++) {
RedisModule_ReplyWithLongLong(ctx, pvec[i]);
}
}
/* HELLO.RAND.ARRAY <count>
* Shows how to generate arrays as commands replies.
* It just outputs <count> random numbers. */
int HelloRandArray_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
if (argc != 2) return RedisModule_WrongArity(ctx);
long long count;
if (RedisModule_StringToLongLong(argv[1],&count) != REDISMODULE_OK ||
count < 0)
return RedisModule_ReplyWithError(ctx,"ERR invalid count");
/* To reply with an array, we call RedisModule_ReplyWithArray() followed
* by other "count" calls to other reply functions in order to generate
* the elements of the array. */
RedisModule_ReplyWithArray(ctx,count);
while(count--) RedisModule_ReplyWithLongLong(ctx,rand());
return REDISMODULE_OK;
}
/* HELLO.ZSUMRANGE key startscore endscore
* Return the sum of all the scores elements between startscore and endscore.
*
* The computation is performed two times, one time from start to end and
* another time backward. The two scores, returned as a two element array,
* should match.*/
int HelloZsumRange_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
double score_start, score_end;
if (argc != 4) return RedisModule_WrongArity(ctx);
if (RedisModule_StringToDouble(argv[2],&score_start) != REDISMODULE_OK ||
RedisModule_StringToDouble(argv[3],&score_end) != REDISMODULE_OK)
{
return RedisModule_ReplyWithError(ctx,"ERR invalid range");
}
RedisModuleKey *key = RedisModule_OpenKey(ctx,argv[1],
REDISMODULE_READ|REDISMODULE_WRITE);
if (RedisModule_KeyType(key) != REDISMODULE_KEYTYPE_ZSET) {
return RedisModule_ReplyWithError(ctx,REDISMODULE_ERRORMSG_WRONGTYPE);
}
double scoresum_a = 0;
double scoresum_b = 0;
RedisModule_ZsetFirstInScoreRange(key,score_start,score_end,0,0);
while(!RedisModule_ZsetRangeEndReached(key)) {
double score;
RedisModuleString *ele = RedisModule_ZsetRangeCurrentElement(key,&score);
RedisModule_FreeString(ctx,ele);
scoresum_a += score;
RedisModule_ZsetRangeNext(key);
}
RedisModule_ZsetRangeStop(key);
RedisModule_ZsetLastInScoreRange(key,score_start,score_end,0,0);
while(!RedisModule_ZsetRangeEndReached(key)) {
double score;
RedisModuleString *ele = RedisModule_ZsetRangeCurrentElement(key,&score);
RedisModule_FreeString(ctx,ele);
scoresum_b += score;
RedisModule_ZsetRangePrev(key);
}
RedisModule_ZsetRangeStop(key);
RedisModule_CloseKey(key);
RedisModule_ReplyWithArray(ctx,2);
RedisModule_ReplyWithDouble(ctx,scoresum_a);
RedisModule_ReplyWithDouble(ctx,scoresum_b);
return REDISMODULE_OK;
}
void SpellCheck_Reply(SpellCheckCtx *scCtx, QueryAST *q) {
if (!SpellCheck_CheckTermDictsExistance(scCtx)) {
return;
}
RedisModule_ReplyWithArray(scCtx->sctx->redisCtx, REDISMODULE_POSTPONED_ARRAY_LEN);
if (scCtx->fullScoreInfo) {
// sending the total number of docs for the ability to calculate score on cluster
RedisModule_ReplyWithLongLong(scCtx->sctx->redisCtx, scCtx->sctx->spec->docs.size - 1);
}
QueryNode_ForEach(q->root, forEachCallback, scCtx, 1);
RedisModule_ReplySetArrayLength(scCtx->sctx->redisCtx,
scCtx->results + (scCtx->fullScoreInfo ? 1 : 0));
}
/* Serialize all the tags in the index to the redis client */
void TagIndex_SerializeValues(TagIndex *idx, RedisModuleCtx *ctx) {
TrieMapIterator *it = TrieMap_Iterate(idx->values, "", 0);
char *str;
tm_len_t slen;
void *ptr;
RedisModule_ReplyWithArray(ctx, REDISMODULE_POSTPONED_ARRAY_LEN);
long long count = 0;
while (TrieMapIterator_Next(it, &str, &slen, &ptr)) {
++count;
RedisModule_ReplyWithStringBuffer(ctx, str, slen);
}
RedisModule_ReplySetArrayLength(ctx, count);
TrieMapIterator_Free(it);
}
static bool SpellCheck_ReplyTermSuggestions(SpellCheckCtx *scCtx, char *term, size_t len,
t_fieldMask fieldMask) {
// searching the term on the term trie, if its there we just return false
// because there is no need to return suggestions on it.
if (SpellCheck_IsTermExistsInTrie(scCtx->sctx->spec->terms, term, len, NULL)) {
if (scCtx->fullScoreInfo) {
// if a full score info is requested we need to send information that
// we found the term as is on the index
RedisModule_ReplyWithArray(scCtx->sctx->redisCtx, 3);
RedisModule_ReplyWithStringBuffer(scCtx->sctx->redisCtx, TERM, strlen(TERM));
RedisModule_ReplyWithStringBuffer(scCtx->sctx->redisCtx, term, len);
RedisModule_ReplyWithStringBuffer(scCtx->sctx->redisCtx, FOUND_TERM_IN_INDEX,
strlen(FOUND_TERM_IN_INDEX));
return true;
} else {
return false;
}
}
// searching the term on the exclude list, if its there we just return false
// because there is no need to return suggestions on it.
for (int i = 0; i < array_len(scCtx->excludeDict); ++i) {
RedisModuleKey *k = NULL;
Trie *t =
SpellCheck_OpenDict(scCtx->sctx->redisCtx, scCtx->excludeDict[i], REDISMODULE_READ, &k);
if (t == NULL) {
continue;
}
if (SpellCheck_IsTermExistsInTrie(t, term, len, NULL)) {
RedisModule_CloseKey(k);
return false;
}
RedisModule_CloseKey(k);
}
RS_Suggestions *s = RS_SuggestionsCreate();
SpellCheck_FindSuggestions(scCtx, scCtx->sctx->spec->terms, term, len, fieldMask, s, 1);
// sorting results by score
// searching the term on the include list for more suggestions.
for (int i = 0; i < array_len(scCtx->includeDict); ++i) {
RedisModuleKey *k = NULL;
Trie *t =
SpellCheck_OpenDict(scCtx->sctx->redisCtx, scCtx->includeDict[i], REDISMODULE_READ, &k);
if (t == NULL) {
continue;
}
SpellCheck_FindSuggestions(scCtx, t, term, len, fieldMask, s, 0);
RedisModule_CloseKey(k);
}
SpellCheck_SendReplyOnTerm(scCtx->sctx->redisCtx, term, len, s,
(!scCtx->fullScoreInfo) ? scCtx->sctx->spec->docs.size - 1 : 0);
RS_SuggestionsFree(s);
return true;
}
static void PopReplyString(RedisModuleCtx *ctx, sds skey, sds sval) {
RedisModule_ReplyWithArray(ctx, 2);
RedisModule_ReplyWithStringBuffer(ctx, skey, sdslen(skey));
RedisModule_ReplyWithStringBuffer(ctx, sval, sdslen(sval));
}