static void gossip_metainfo(void) { dictIterator *dc_it; dictEntry *dc_de; dc_it = dictGetIterator(gn_pool.dict_dc); while ((dc_de = dictNext(dc_it)) != NULL) { struct gossip_dc *g_dc = dictGetVal(dc_de); log_debug(LOG_VERB, "\tDC name : '%.*s'", g_dc->name.len, g_dc->name.data); dictIterator *rack_it = dictGetIterator(g_dc->dict_rack); dictEntry *rack_de; while ((rack_de = dictNext(rack_it)) != NULL) { struct gossip_rack *g_rack = dictGetVal(rack_de); log_debug(LOG_VERB, "\tRack name : '%.*s'", g_rack->name.len, g_rack->name.data); dictIterator *node_it = dictGetIterator(g_rack->dict_token_nodes); dictEntry *node_de; int i = 0; while ((node_de = dictNext(node_it)) != NULL) { struct node *gnode = dictGetVal(node_de); log_debug(LOG_VERB, "\tNode name : '%.*s'", gnode->name.len, gnode->name.data); struct string *token_key = dictGetKey(node_de); log_debug(LOG_VERB, "\tNode token : '%.*s'", *token_key); } } } }
void callback_recurse(Engine *engine, dict *term_index, dict *query_nodes, void *doc, bool positive) { assert(doc); if(positive) { QueryNode *n = dictFetchValue(query_nodes, &SENTINEL); if (n) { DEBUG("recursing SENTINEL"); callback_recurse(engine, term_index, n->children, doc, false); } } if(dictSize(term_index) > dictSize(query_nodes) || !positive){ dictIterator *iterator = dictGetIterator(query_nodes); dictEntry *next; while ((next = dictNext(iterator))) { if (positive == !!dictFetchValue(term_index, dictGetKey(next))) { QueryNode *node = dictGetVal(next); Callback *cb = node->callback; assert(node->term->owns_string); DEBUG("perc'd %.*s:%.*s", node->term->field.len, node->term->field.val, node->term->text.len, node->term->text.val); while(cb) { DEBUG("running callback %d", cb->id); cb->handler(cb, doc); cb = cb->next; } if(node->children) { callback_recurse(engine, term_index, node->children, doc, positive); } } } dictReleaseIterator(iterator); } else { dictIterator *iterator = dictGetIterator(term_index); dictEntry *next; QueryNode *node; while ((next = dictNext(iterator))) { if(positive == !!(node = dictFetchValue(query_nodes, dictGetKey(next)))) { Callback *cb = node->callback; DEBUG("perc'd %.*s:%.*s", node->term->field.len, node->term->field.val, node->term->text.len, node->term->text.val); while(cb) { DEBUG("running callback %d", cb->id); cb->handler(cb, doc); cb = cb->next; } if(node->children){ callback_recurse(engine, term_index, node->children, doc,positive); } } } dictReleaseIterator(iterator); } }
/* Helper function to free the context. */ static void __redisAsyncFree(redisAsyncContext *ac) { redisContext *c = &(ac->c); redisCallback cb; dictIterator *it; dictEntry *de; // 执行所有等待队列中回调函数,将空回复传进去 /* Execute pending callbacks with NULL reply. */ while (__redisShiftCallback(&ac->replies,&cb) == REDIS_OK) __redisRunCallback(ac,&cb,NULL); // 执行所有等待队列中回调函数,将空回复传进去 // 这里是无效命令的回调函数 /* Execute callbacks for invalid commands */ while (__redisShiftCallback(&ac->sub.invalid,&cb) == REDIS_OK) __redisRunCallback(ac,&cb,NULL); // 执行所有等待队列中回调函数,将空回复传进去 // 这里是订阅发布的回调函数 /* Run subscription callbacks callbacks with NULL reply */ it = dictGetIterator(ac->sub.channels); while ((de = dictNext(it)) != NULL) __redisRunCallback(ac,dictGetEntryVal(de),NULL); dictReleaseIterator(it); dictRelease(ac->sub.channels); // 执行所有等待队列中回调函数,将空回复传进去 // 这里是订阅发布的回调函数 it = dictGetIterator(ac->sub.patterns); while ((de = dictNext(it)) != NULL) __redisRunCallback(ac,dictGetEntryVal(de),NULL); dictReleaseIterator(it); dictRelease(ac->sub.patterns); // 注销连接上的读写事件 /* Signal event lib to clean up */ _EL_CLEANUP(ac); // 执行连接关闭回调函数,可做一些清理工作 /* Execute disconnect callback. When redisAsyncFree() initiated destroying * this context, the status will always be REDIS_OK. */ if (ac->onDisconnect && (c->flags & REDIS_CONNECTED)) { if (c->flags & REDIS_FREEING) { ac->onDisconnect(ac,REDIS_OK); } else { ac->onDisconnect(ac,(ac->err == 0) ? REDIS_OK : REDIS_ERR); } } // 释放 redisContext 中的内存 /* Cleanup self */ redisFree(c); }
void countersSync(clusterNode *node) { dictIterator *it; dictEntry *de; it = dictGetIterator(server.counters); while ((de = dictNext(it)) != NULL) { counter *cntr; listNode *ln; listIter li; shard *shrd; cntr = dictGetVal(de); /* If we have our own shard make sure to send it's prediction * to the new node. */ if (cntr->myshard) { clusterSendShardToNode(cntr, node); } listRewind(cntr->shards,&li); while ((ln = listNext(&li)) != NULL) { shrd = listNodeValue(ln); if (memcmp(shrd->node_name, node->name, CLUSTER_NAMELEN) == 0) { shrd->node = node; } } } dictReleaseIterator(it); }
static int createAllCFSfromConfig() { dictEntry *de = NULL; dictIterator *di = NULL; if(!g_dataModel.cfsHashTable) return -1; di = dictGetIterator(g_cfmDict); if(!di){ return -1; } de = dictNext(di); while(de){ columnFamilyMetadata *cfmd = (columnFamilyMetadata *) dictGetEntryKey(de); columnFamilyStore *cfs = NULL; if(!cfmd || !(cfs = getCFStore(cfmd))){ dictReleaseIterator(di); return -1; } if(insertDMCFS(cfs) < 0){ dictReleaseIterator(di); freeHeapCFStore(cfs); return -1; } de = dictNext(di); } dictReleaseIterator(di); return 0; }
static void conf_organization_dump(sds name, dict *org, int log_level) { dictIterator *di; dictEntry *de; sds key; conf_value *cv; if(name == NULL || org == NULL){ return; } log_debug(log_level, "[%.*s]", sdslen(name), name); di = dictGetIterator(org); while((de = dictNext(di)) != NULL){ key = dictGetKey(de); cv = dictGetVal(de); if(cv->type == CONF_VALUE_STRING){ log_debug(log_level, "%.*s: %.*s", sdslen(key), key, sdslen(cv->value), cv->value); }else if(cv->type == CONF_VALUE_ARRAY){ log_debug(log_level, "%.*s:",sdslen(key), key); conf_value_dump(cv, log_level); }else{ NOT_REACHED(); } } dictReleaseIterator(di); }
static void conf_organizations_dump(rmt_conf *cf) { dict *orgs, *org; dictIterator *di; dictEntry *de; sds name; int log_level = LOG_VERB; if(cf == NULL){ return; } orgs = cf->organizations; if(orgs == NULL){ log_debug(log_level, "organization is NULL"); return; } di = dictGetIterator(orgs); while((de = dictNext(di)) != NULL){ name = dictGetKey(de); org = dictGetVal(de); conf_organization_dump(name, org, log_level); log_debug(log_level, ""); } dictReleaseIterator(di); }
/* Unblock a client that's waiting in a blocking operation such as BLPOP */ void unblockClientWaitingData(redisClient *c) { dictEntry *de; dictIterator *di; list *l; redisAssertWithInfo(c,NULL,dictSize(c->bpop.keys) != 0); di = dictGetIterator(c->bpop.keys); /* The client may wait for multiple keys, so unblock it for every key. */ while((de = dictNext(di)) != NULL) { robj *key = dictGetKey(de); /* Remove this client from the list of clients waiting for this key. */ l = dictFetchValue(c->db->blocking_keys,key); redisAssertWithInfo(c,key,l != NULL); listDelNode(l,listSearchKey(l,c)); /* If the list is empty we need to remove it to avoid wasting memory */ if (listLength(l) == 0) dictDelete(c->db->blocking_keys,key); } dictReleaseIterator(di); /* Cleanup the client structure */ dictEmpty(c->bpop.keys,NULL); if (c->bpop.target) { decrRefCount(c->bpop.target); c->bpop.target = NULL; } c->flags &= ~REDIS_BLOCKED; c->flags |= REDIS_UNBLOCKED; server.bpop_blocked_clients--; listAddNodeTail(server.unblocked_clients,c); }
void call_expire_delete_event(void *pdb,void *pkeyobj) { redisDb *db=(redisDb *)pdb; robj *myobj=(robj *)pkeyobj; robj *keyobj = createStringObject(myobj->ptr,sdslen(myobj->ptr)); struct dictIterator *iter=dictGetIterator(server.bridge_db.triggle_scipts[db->id]); dictEntry *trigs; do{ trigs=dictNext(iter); if(trigs!=NULL) { struct bridge_db_triggle_t * tmptrg=dictGetVal(trigs); //add func str check for the function only the key satisfy the funcname:XXXX can call the event if(tmptrg->event==DELETE_EXPIRE&&strncmp(keyobj->ptr,dictGetKey(trigs),sdslen(dictGetKey(trigs)))==0){ //找到指定的类型事件 redisLog(REDIS_NOTICE,"triggle_event:%d,%s",DELETE_EXPIRE,(char *)dictGetKey(trigs)); triggle_expire_event(db,dictGetKey(trigs),keyobj); } } }while(trigs!=NULL); dictReleaseIterator(iter); decrRefCount(keyobj); }
/* Unblock a client that's waiting in a blocking operation such as BLPOP. * You should never call this function directly, but unblockClient() instead. */ void unblockClientWaitingData(redisClient *c) { dictEntry *de; dictIterator *di; list *l; redisAssertWithInfo(c,NULL,dictSize(c->bpop.keys) != 0); di = dictGetIterator(c->bpop.keys); /* The client may wait for multiple keys, so unblock it for every key. */ while((de = dictNext(di)) != NULL) { robj *key = dictGetKey(de); redisDb *db = &(c->db)[keyHashSlot(key->ptr, sdslen(key->ptr))]; /* Remove this client from the list of clients waiting for this key. */ l = dictFetchValue(db->blocking_keys,key); redisAssertWithInfo(c,key,l != NULL); listDelNode(l,listSearchKey(l,c)); /* If the list is empty we need to remove it to avoid wasting memory */ if (listLength(l) == 0) dictDelete(db->blocking_keys,key); } dictReleaseIterator(di); /* Cleanup the client structure */ dictEmpty(c->bpop.keys,NULL); if (c->bpop.target) { decrRefCount(c->bpop.target); c->bpop.target = NULL; } }
void delkeysCommand(redisClient *c) { dictIterator *di; dictEntry *de; sds pattern = c->argv[1]->ptr; int plen = sdslen(pattern), allkeys; unsigned long deleted = 0; di = dictGetIterator(c->db->dict); allkeys = (pattern[0] == '*' && pattern[1] == '\0'); while((de = dictNext(di)) != NULL) { sds key = dictGetEntryKey(de); robj *keyobj; if (allkeys || stringmatchlen(pattern,plen,key,sdslen(key),0)) { keyobj = createStringObject(key,sdslen(key)); if (dbDelete(c->db,keyobj)) { touchWatchedKey(c->db,keyobj); server.dirty++; deleted++; } decrRefCount(keyobj); } } dictReleaseIterator(di); addReplyLongLong(c,deleted); }
void dbPrintSets(FILE *f) { dictIterator *iter = NULL; dictEntry *entry = NULL; if (NULL == f) return; lockRead(sets); if (0 == dictSize(sets)) { unlockRead(sets); fprintf(f, "No sets in db.\r\n"); return; } if (NULL == (iter = dictGetIterator(sets))) { unlockRead(sets); return; } while (NULL != (entry = dictNext(iter))) { fprintf(f, "%s\r\n", dictGetEntryKey(entry)); lockRead(dictGetEntryVal(entry)); setPrint((set *) dictGetEntryVal(entry), f, 1); unlockRead(dictGetEntryVal(entry)); fprintf(f, "\r\n"); } dictReleaseIterator(iter); unlockRead(sets); }
int dbFlushAll(void) { dictIterator *iter = NULL; dictEntry *entry = NULL; lockWrite(sets); if (NULL == (iter = dictGetIterator(sets))) { unlockWrite(sets); return -1; } while (NULL != (entry = dictNext(iter))) { set *s = (set *) dictGetEntryVal(entry); lockWrite(s); if (!s->registered) setDestroy(s); unregisterSyncObject(s); } dictReleaseIterator(iter); dictEmpty(sets); unlockWrite(sets); return 0; }
void keysCommand(redisClient *c) { dictIterator *di; dictEntry *de; sds pattern = c->argv[1]->ptr; int plen = sdslen(pattern); unsigned long numkeys = 0; robj *lenobj = createObject(REDIS_STRING,NULL); di = dictGetIterator(c->db->dict); addReply(c,lenobj); decrRefCount(lenobj); while((de = dictNext(di)) != NULL) { sds key = dictGetEntryKey(de); robj *keyobj; if ((pattern[0] == '*' && pattern[1] == '\0') || stringmatchlen(pattern,plen,key,sdslen(key),0)) { keyobj = createStringObject(key,sdslen(key)); if (expireIfNeeded(c->db,keyobj) == 0) { addReplyBulk(c,keyobj); numkeys++; } decrRefCount(keyobj); } } dictReleaseIterator(di); lenobj->ptr = sdscatprintf(sdsempty(),"*%lu\r\n",numkeys); }
//解阻塞一个正在阻塞中的client void unblockClientWaitingData(client *c) { dictEntry *de; dictIterator *di; list *l; serverAssertWithInfo(c,NULL,dictSize(c->bpop.keys) != 0); //创建一个字典的迭代器,指向的是造成client阻塞的键所组成的字典 di = dictGetIterator(c->bpop.keys); /* The client may wait for multiple keys, so unblock it for every key. */ //因为client可能被多个key所阻塞,所以要遍历所有的键 while((de = dictNext(di)) != NULL) { robj *key = dictGetKey(de); //获得key对象 /* Remove this client from the list of clients waiting for this key. */ //根据key找到对应的列表类型值,值保存着被阻塞的client,从中找c->db->blocking_keys中寻找 l = dictFetchValue(c->db->blocking_keys,key); serverAssertWithInfo(c,key,l != NULL); // 将阻塞的client从列表中移除 listDelNode(l,listSearchKey(l,c)); /* If the list is empty we need to remove it to avoid wasting memory */ //如果当前列表为空了,则从c->db->blocking_keys中将key删除 if (listLength(l) == 0) dictDelete(c->db->blocking_keys,key); } dictReleaseIterator(di); //释放迭代器 /* Cleanup the client structure */ //清空bpop.keys的所有节点 dictEmpty(c->bpop.keys,NULL); //如果保存有新添加的元素,则应该释放 if (c->bpop.target) { decrRefCount(c->bpop.target); c->bpop.target = NULL; } }
void keysCommand(redisClient *c) { dictIterator *di; dictEntry *de; sds pattern = c->argv[1]->ptr; int plen = sdslen(pattern), allkeys; unsigned long numkeys = 0; void *replylen = addDeferredMultiBulkLength(c); di = dictGetIterator(c->db->dict); allkeys = (pattern[0] == '*' && pattern[1] == '\0'); while((de = dictNext(di)) != NULL) { sds key = dictGetEntryKey(de); robj *keyobj; if (allkeys || stringmatchlen(pattern,plen,key,sdslen(key),0)) { keyobj = createStringObject(key,sdslen(key)); if (expireIfNeeded(c->db,keyobj) == 0) { addReplyBulk(c,keyobj); numkeys++; } decrRefCount(keyobj); } } dictReleaseIterator(di); setDeferredMultiBulkLength(c,replylen,numkeys); }
void _engine_apply_ints(Engine *engine, DocBuf *buffer, long doc_id) { dictIterator *iter = dictGetIterator(engine->ints); dictEntry *entry; while ((entry = dictNext(iter))) { pstring *key = dictGetKey(entry); engine_set_int(engine, doc_id, key, 0); } dictReleaseIterator(iter); iter = dictGetIterator(buffer->ints); while ((entry = dictNext(iter))) { pstring *key = dictGetKey(entry); int val = dictGetSignedIntegerVal(entry); engine_set_int(engine, doc_id, key, val); } dictReleaseIterator(iter); }
/* scriptNameCommand() has compound sub-arguments, so it looks slightly more * convoluted than it actually is. Just read each if/else branch as * if it were an individual command. */ void scriptNameCommand(redisClient *c) { char *req = c->argv[1]->ptr; sds script_name = c->argv[2]->ptr; if (c->argc == 4 && !strcasecmp(req, "set")) { sds target_sha = c->argv[3]->ptr; if (sdslen(target_sha) != 40 || dictFind(server.lua_scripts,target_sha) == NULL) { addReply(c, g.err.nosha); return; } /* If name doesn't exist, dictReplace == dictAdd */ dictReplace(g.names, script_name, target_sha); addReplyBulkCBuffer(c, script_name, sdslen(script_name)); } else if (c->argc == 3 && !strcasecmp(req, "get")) { sds found; if ((found = dictFetchValue(g.names, script_name))) { addReplyBulkCBuffer(c, found, sdslen(found)); } else { addReply(c, g.err.noname); } } else if (c->argc == 2 && !strcasecmp(req, "getall")) { dictIterator *di; dictEntry *de; unsigned long sz = dictSize(g.names); if (!sz) { addReply(c, shared.emptymultibulk); return; } /* Multiply by 2 because the size of the dict is the number of keys. * We are returning keys *and* values, so length is dictSize * 2 */ addReplyMultiBulkLen(c, sz * 2); di = dictGetIterator(g.names); while ((de = dictNext(di))) { addReplyBulkCString(c, dictGetKey(de)); addReplyBulkCString(c, dictGetVal(de)); } dictReleaseIterator(di); } else if (c->argc == 3 && !strcasecmp(req, "del")) { sds deleted; if ((deleted = dictFetchValue(g.names, script_name))) { dictDelete(g.names, script_name); addReplyBulkCBuffer(c, deleted, sdslen(deleted)); } else { addReply(c, g.err.noname); } } else { addReplyError(c, "Unknown scriptName subcommand or arg count"); } }
void processCleanup(void) { dictIterator *di = dictGetIterator(server.process); dictEntry *de; while ((de = dictNext(di)) != NULL) { struct ProcessInfo *p = dictGetEntryVal(de); if (p->time_stamp != g_time) deleteProcess(p->pid); } dictReleaseIterator(di); }
static void freeDictOfIndRow(dict *d, int num_cols, bool is_ob) { dictEntry *ide; dictIterator *idi = dictGetIterator(d); while((ide = dictNext(idi)) != NULL) { robj *ikey = dictGetEntryKey(ide); freeIndRow(ikey->ptr, num_cols, is_ob, 0); } dictReleaseIterator(idi); }
/* PUBSUB command for Pub/Sub introspection. */ void pubsubCommand(redisClient *c) { // 处理PUBSUB CHANNELS [pattern]命令 if (!strcasecmp(c->argv[1]->ptr,"channels") && (c->argc == 2 || c->argc ==3)) { /* PUBSUB CHANNELS [<pattern>] */ // 获取pattern参数,如果没有则为NULL sds pat = (c->argc == 2) ? NULL : c->argv[2]->ptr; dictIterator *di = dictGetIterator(server.pubsub_channels); dictEntry *de; long mblen = 0; void *replylen; replylen = addDeferredMultiBulkLength(c); // 遍历server.pubsub_channels字典 while((de = dictNext(di)) != NULL) { // 取出当前频道channel robj *cobj = dictGetKey(de); sds channel = cobj->ptr; // 如果没有给定pattern参数,则打印出所有频道 // 如果给定pattern参数,则打印出与pattern参数相匹配的频道 if (!pat || stringmatchlen(pat, sdslen(pat), channel, sdslen(channel),0)) { addReplyBulk(c,cobj); mblen++; } } dictReleaseIterator(di); setDeferredMultiBulkLength(c,replylen,mblen); } // 处理PUBSUB NUMSUB [Channel_1 ... Channel_N]命令 else if (!strcasecmp(c->argv[1]->ptr,"numsub") && c->argc >= 2) { /* PUBSUB NUMSUB [Channel_1 ... Channel_N] */ int j; addReplyMultiBulkLen(c,(c->argc-2)*2); for (j = 2; j < c->argc; j++) { list *l = dictFetchValue(server.pubsub_channels,c->argv[j]); addReplyBulk(c,c->argv[j]); addReplyLongLong(c,l ? listLength(l) : 0); } } // 处理PUBSUB NUMPA命令 else if (!strcasecmp(c->argv[1]->ptr,"numpat") && c->argc == 2) { /* PUBSUB NUMPAT */ addReplyLongLong(c,listLength(server.pubsub_patterns)); } else { addReplyErrorFormat(c, "Unknown PUBSUB subcommand or wrong number of arguments for '%s'", (char*)c->argv[1]->ptr); } }
void countersUpdateValues(void) { dictIterator *it; dictEntry *de; mstime_t now = mstime(); it = dictGetIterator(server.counters); while ((de = dictNext(it)) != NULL) { long double elapsed, value = 0; counter *cntr; listNode *ln; listIter li; shard *shrd; cntr = dictGetVal(de); listRewind(cntr->shards,&li); while ((ln = listNext(&li)) != NULL) { shrd = listNodeValue(ln); /* Don't do a prediction with our own shard. */ if (shrd == cntr->myshard) { value += shrd->value; continue; } /* Don't update predictions for failing nodes. */ if (shrd->node == NULL || nodeFailed(shrd->node)) { /* Leave the prediction as it is. */ /* TODO: Since this function is called 10 times per second we can't really do any debug output here. */ /*serverLog(LL_DEBUG,"Counter %s not updating shard of %.40s", cntr->name, shrd->node_name);*/ } else if (shrd->predict_time > 0 && shrd->predict_value != 0) { elapsed = now - shrd->predict_time; shrd->value = shrd->predict_value + (elapsed * shrd->predict_change); /*serverLog(LL_DEBUG,"Counter %s new value %Lf for shard %.40s", cntr->name, shrd->value, shrd->node_name); } else { serverLog(LL_DEBUG,"Counter %s not using shard of %.40s %llu %Lf", cntr->name, shrd->node_name, shrd->predict_time, shrd->predict_value);*/ } value += shrd->value; } if (cntr->value != value) { cntr->value = value; /* Make sure the cached response gets recalculated. */ cntr->rlen = 0; } } dictReleaseIterator(it); }
void movekeysCommand(redisClient *c) { redisDb *src, *dst; int srcid; dictIterator *di; dictEntry *de; sds pattern = c->argv[1]->ptr; int plen = sdslen(pattern), allkeys; unsigned long numkeys = 0; /* Obtain source and target DB pointers */ src = c->db; srcid = c->db->id; if (selectDb(c,atoi(c->argv[2]->ptr)) == REDIS_ERR) { addReply(c,shared.outofrangeerr); return; } dst = c->db; selectDb(c,srcid); /* Back to the source DB */ /* If the user is moving using as target the same * DB as the source DB it is probably an error. */ if (src == dst) { addReply(c,shared.sameobjecterr); return; } di = dictGetIterator(c->db->dict); allkeys = (pattern[0] == '*' && pattern[1] == '\0'); while((de = dictNext(di)) != NULL) { sds key = dictGetEntryKey(de); robj *keyobj; if (allkeys || stringmatchlen(pattern,plen,key,sdslen(key),0)) { keyobj = createStringObject(key,sdslen(key)); if (expireIfNeeded(c->db,keyobj) == 0) { robj *val = dictGetEntryVal(de); /* Try to add the element to the target DB */ if (dbAdd(dst,keyobj,val) != REDIS_ERR) { incrRefCount(val); /* OK! key moved, free the entry in the source DB */ dbDelete(src,keyobj); server.dirty++; numkeys++; } } decrRefCount(keyobj); } } dictReleaseIterator(di); addReplyLongLong(c,numkeys); }
static bool buildJRowReply(build_jrow_reply_t *b, int lvl, robj *rset[MAX_JOIN_INDXS]) { dictIterator *iter; dictEntry *rde = dictFind(rset[lvl]->ptr, b->jk); if (rde) { robj *setobj = dictGetEntryVal(rde); iter = dictGetIterator(setobj->ptr); } else { // this table does not have this column if (b->j.obt == Index[server.dbid][b->j_indxs[lvl]].table) { Order_by_col_val = NULL; } for (int j = 0; j < b->j.jind_ncols[lvl]; j++) { Rcols[lvl][j] = &EMPTY_STRING; Rc_lens[lvl][j] = 0; } if (lvl + 1 < b->n_ind) { if(!buildJRowReply(b, lvl + 1, rset)) return 0; } else { if (!jRowReply(&(b->j), lvl)) return 0; *b->card = *b->card + 1; } return 1; } dictEntry *sde; while ((sde = dictNext(iter)) != NULL) { char *first_entry; robj *item = sde->key; if (b->j.obt == Index[server.dbid][b->j_indxs[lvl]].table) { obsl_t *ob = (obsl_t *)item->ptr; Order_by_col_val = ob->keys[0]; first_entry = (char *)ob->row; } else { first_entry = (char *)item->ptr; } for (int j = 0; j < b->j.jind_ncols[lvl]; j++) { Rcols[lvl][j] = (char **)first_entry; first_entry += PTR_SIZE; memcpy(&(Rc_lens[lvl][j]), first_entry, UINT_SIZE); first_entry += UINT_SIZE; } if (lvl + 1 < b->n_ind) { if(!buildJRowReply(b, lvl + 1, rset)) return 0; } else { if (!jRowReply(&(b->j), lvl)) return 0; *b->card = *b->card + 1; } } dictReleaseIterator(iter); return 1; }
/* Unsubscribe from all the channels. Return the number of channels the * client was subscribed from. */ int pubsubUnsubscribeAllChannels(redisClient *c, int notify) { dictIterator *di = dictGetIterator(c->pubsub_channels); dictEntry *de; int count = 0; while((de = dictNext(di)) != NULL) { robj *channel = dictGetEntryKey(de); count += pubsubUnsubscribeChannel(c,channel,notify); } dictReleaseIterator(di); return count; }
void _recurse_each(Callback *cb, dict *hash) { dictIterator * iterator = dictGetIterator(hash); dictEntry *next; while((next = dictNext(iterator))) { QueryNode *node = dictGetVal(next); cb->handler(cb, node); if(node->children) { _recurse_each(cb, node->children); } } dictReleaseIterator(iterator); }
setTypeIterator *setTypeInitIterator(robj *subject) { setTypeIterator *si = zmalloc(sizeof(setTypeIterator)); si->subject = subject; si->encoding = subject->encoding; if (si->encoding == REDIS_ENCODING_HT) { si->di = dictGetIterator(subject->ptr); } else if (si->encoding == REDIS_ENCODING_INTSET) { si->ii = 0; } else { redisPanic("Unknown set encoding"); } return si; }
void destroyTaskMap(dict* p) { if (p) { dictIterator* di = dictGetIterator(p); dictEntry* de; while ((de = dictNext(di)) != NULL) { ugTaskType* ptask = dictGetEntryVal(de); luaworkUnrefFunction(server.ls, ptask->handle, NULL); } dictReleaseIterator(di); dictRelease(p); } }
static void shutdown_server(EV_P_ ev_signal *w, int revents) { IGNORE_VAR(w); IGNORE_VAR(revents); IGNORE_VAR(dictGenHashFunction); IGNORE_VAR(dictCreate); IGNORE_VAR(dictReplace); IGNORE_VAR(dictRelease); dictEntry *de; dictIterator *iter = dictGetIterator(active_connections); while ((de = dictNext(iter)) != NULL) { muxConn *mc = de->val; // stop any pending writes ev_io_stop(EV_A_ mc->watcher); disconnectAndClean(mc); } dictReleaseIterator(iter); ev_break(EV_A_ EVBREAK_ALL); }
hashTypeIterator *hashTypeInitIterator(robj *subject) { hashTypeIterator *hi = zmalloc(sizeof(hashTypeIterator)); hi->subject = subject; hi->encoding = subject->encoding; if (hi->encoding == REDIS_ENCODING_ZIPLIST) { hi->fptr = NULL; hi->vptr = NULL; } else if (hi->encoding == REDIS_ENCODING_HT) { hi->di = dictGetIterator(subject->ptr); } else { logicError("Unknown hash encoding"); } return hi; }