]> git.saurik.com Git - redis.git/blob - src/t_hash.c
projects / redis.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
RDB4 support in redis-check-dump.
[redis.git] / src / t_hash.c
1 #include "redis.h"
2 #include <math.h>
3
4 /*-----------------------------------------------------------------------------
5 * Hash type API
6 *----------------------------------------------------------------------------*/
7
8 /* Check the length of a number of objects to see if we need to convert a
9 * ziplist to a real hash. Note that we only check string encoded objects
10 * as their string length can be queried in constant time. */
11 void hashTypeTryConversion(robj *o, robj **argv, int start, int end) {
12 int i;
13
14 if (o->encoding != REDIS_ENCODING_ZIPLIST) return;
15
16 for (i = start; i <= end; i++) {
17 if (argv[i]->encoding == REDIS_ENCODING_RAW &&
18 sdslen(argv[i]->ptr) > server.hash_max_ziplist_value)
19 {
20 hashTypeConvert(o, REDIS_ENCODING_HT);
21 break;
22 }
23 }
24 }
25
26 /* Encode given objects in-place when the hash uses a dict. */
27 void hashTypeTryObjectEncoding(robj *subject, robj **o1, robj **o2) {
28 if (subject->encoding == REDIS_ENCODING_HT) {
29 if (o1) *o1 = tryObjectEncoding(*o1);
30 if (o2) *o2 = tryObjectEncoding(*o2);
31 }
32 }
33
34 /* Get the value from a ziplist encoded hash, identified by field.
35 * Returns -1 when the field cannot be found. */
36 int hashTypeGetFromZiplist(robj *o, robj *field,
37 unsigned char **vstr,
38 unsigned int *vlen,
39 long long *vll)
40 {
41 unsigned char *zl, *fptr = NULL, *vptr = NULL;
42 int ret;
43
44 redisAssert(o->encoding == REDIS_ENCODING_ZIPLIST);
45
46 field = getDecodedObject(field);
47
48 zl = o->ptr;
49 fptr = ziplistIndex(zl, ZIPLIST_HEAD);
50 if (fptr != NULL) {
51 fptr = ziplistFind(fptr, field->ptr, sdslen(field->ptr), 1);
52 if (fptr != NULL) {
53 /* Grab pointer to the value (fptr points to the field) */
54 vptr = ziplistNext(zl, fptr);
55 redisAssert(vptr != NULL);
56 }
57 }
58
59 decrRefCount(field);
60
61 if (vptr != NULL) {
62 ret = ziplistGet(vptr, vstr, vlen, vll);
63 redisAssert(ret);
64 return 0;
65 }
66
67 return -1;
68 }
69
70 /* Get the value from a hash table encoded hash, identified by field.
71 * Returns -1 when the field cannot be found. */
72 int hashTypeGetFromHashTable(robj *o, robj *field, robj **value) {
73 dictEntry *de;
74
75 redisAssert(o->encoding == REDIS_ENCODING_HT);
76
77 de = dictFind(o->ptr, field);
78 if (de == NULL) return -1;
79 *value = dictGetVal(de);
80 return 0;
81 }
82
83 /* Higher level function of hashTypeGet*() that always returns a Redis
84 * object (either new or with refcount incremented), so that the caller
85 * can retain a reference or call decrRefCount after the usage.
86 *
87 * The lower level function can prevent copy on write so it is
88 * the preferred way of doing read operations. */
89 robj *hashTypeGetObject(robj *o, robj *field) {
90 robj *value = NULL;
91
92 if (o->encoding == REDIS_ENCODING_ZIPLIST) {
93 unsigned char *vstr = NULL;
94 unsigned int vlen = UINT_MAX;
95 long long vll = LLONG_MAX;
96
97 if (hashTypeGetFromZiplist(o, field, &vstr, &vlen, &vll) == 0) {
98 if (vstr) {
99 value = createStringObject((char*)vstr, vlen);
100 } else {
101 value = createStringObjectFromLongLong(vll);
102 }
103 }
104
105 } else if (o->encoding == REDIS_ENCODING_HT) {
106 robj *aux;
107
108 if (hashTypeGetFromHashTable(o, field, &aux) == 0) {
109 incrRefCount(aux);
110 value = aux;
111 }
112 } else {
113 redisPanic("Unknown hash encoding");
114 }
115 return value;
116 }
117
118 /* Test if the specified field exists in the given hash. Returns 1 if the field
119 * exists, and 0 when it doesn't. */
120 int hashTypeExists(robj *o, robj *field) {
121 if (o->encoding == REDIS_ENCODING_ZIPLIST) {
122 unsigned char *vstr = NULL;
123 unsigned int vlen = UINT_MAX;
124 long long vll = LLONG_MAX;
125
126 if (hashTypeGetFromZiplist(o, field, &vstr, &vlen, &vll) == 0) return 1;
127 } else if (o->encoding == REDIS_ENCODING_HT) {
128 robj *aux;
129
130 if (hashTypeGetFromHashTable(o, field, &aux) == 0) return 1;
131 } else {
132 redisPanic("Unknown hash encoding");
133 }
134 return 0;
135 }
136
137 /* Add an element, discard the old if the key already exists.
138 * Return 0 on insert and 1 on update. */
139 int hashTypeSet(robj *o, robj *field, robj *value) {
140 int update = 0;
141
142 if (o->encoding == REDIS_ENCODING_ZIPLIST) {
143 unsigned char *zl, *fptr, *vptr;
144
145 field = getDecodedObject(field);
146 value = getDecodedObject(value);
147
148 zl = o->ptr;
149 fptr = ziplistIndex(zl, ZIPLIST_HEAD);
150 if (fptr != NULL) {
151 fptr = ziplistFind(fptr, field->ptr, sdslen(field->ptr), 1);
152 if (fptr != NULL) {
153 /* Grab pointer to the value (fptr points to the field) */
154 vptr = ziplistNext(zl, fptr);
155 redisAssert(vptr != NULL);
156 update = 1;
157
158 /* Delete value */
159 zl = ziplistDelete(zl, &vptr);
160
161 /* Insert new value */
162 zl = ziplistInsert(zl, vptr, value->ptr, sdslen(value->ptr));
163 }
164 }
165
166 if (!update) {
167 /* Push new field/value pair onto the tail of the ziplist */
168 zl = ziplistPush(zl, field->ptr, sdslen(field->ptr), ZIPLIST_TAIL);
169 zl = ziplistPush(zl, value->ptr, sdslen(value->ptr), ZIPLIST_TAIL);
170 }
171
172 o->ptr = zl;
173
174 decrRefCount(field);
175 decrRefCount(value);
176
177 /* Check if the ziplist needs to be converted to a hash table */
178 if (hashTypeLength(o) > server.hash_max_ziplist_entries) {
179 hashTypeConvert(o, REDIS_ENCODING_HT);
180 }
181
182 } else if (o->encoding == REDIS_ENCODING_HT) {
183 if (dictReplace(o->ptr, field, value)) { /* Insert */
184 incrRefCount(field);
185 } else { /* Update */
186 update = 1;
187 }
188
189 incrRefCount(value);
190
191 } else {
192 redisPanic("Unknown hash encoding");
193 }
194
195 return update;
196 }
197
198 /* Delete an element from a hash.
199 * Return 1 on deleted and 0 on not found. */
200 int hashTypeDelete(robj *o, robj *field) {
201 int deleted = 0;
202
203 if (o->encoding == REDIS_ENCODING_ZIPLIST) {
204 unsigned char *zl, *fptr;
205
206 field = getDecodedObject(field);
207
208 zl = o->ptr;
209 fptr = ziplistIndex(zl, ZIPLIST_HEAD);
210 if (fptr != NULL) {
211 fptr = ziplistFind(fptr, field->ptr, sdslen(field->ptr), 1);
212 if (fptr != NULL) {
213 zl = ziplistDelete(zl,&fptr);
214 zl = ziplistDelete(zl,&fptr);
215 o->ptr = zl;
216 deleted = 1;
217 }
218 }
219
220 decrRefCount(field);
221
222 } else if (o->encoding == REDIS_ENCODING_HT) {
223 if (dictDelete((dict*)o->ptr, field) == REDIS_OK) {
224 deleted = 1;
225
226 /* Always check if the dictionary needs a resize after a delete. */
227 if (htNeedsResize(o->ptr)) dictResize(o->ptr);
228 }
229
230 } else {
231 redisPanic("Unknown hash encoding");
232 }
233
234 return deleted;
235 }
236
237 /* Return the number of elements in a hash. */
238 unsigned long hashTypeLength(robj *o) {
239 unsigned long length = ULONG_MAX;
240
241 if (o->encoding == REDIS_ENCODING_ZIPLIST) {
242 length = ziplistLen(o->ptr) / 2;
243 } else if (o->encoding == REDIS_ENCODING_HT) {
244 length = dictSize((dict*)o->ptr);
245 } else {
246 redisPanic("Unknown hash encoding");
247 }
248
249 return length;
250 }
251
252 hashTypeIterator *hashTypeInitIterator(robj *subject) {
253 hashTypeIterator *hi = zmalloc(sizeof(hashTypeIterator));
254 hi->subject = subject;
255 hi->encoding = subject->encoding;
256
257 if (hi->encoding == REDIS_ENCODING_ZIPLIST) {
258 hi->fptr = NULL;
259 hi->vptr = NULL;
260 } else if (hi->encoding == REDIS_ENCODING_HT) {
261 hi->di = dictGetIterator(subject->ptr);
262 } else {
263 redisPanic("Unknown hash encoding");
264 }
265
266 return hi;
267 }
268
269 void hashTypeReleaseIterator(hashTypeIterator *hi) {
270 if (hi->encoding == REDIS_ENCODING_HT) {
271 dictReleaseIterator(hi->di);
272 }
273
274 zfree(hi);
275 }
276
277 /* Move to the next entry in the hash. Return REDIS_OK when the next entry
278 * could be found and REDIS_ERR when the iterator reaches the end. */
279 int hashTypeNext(hashTypeIterator *hi) {
280 if (hi->encoding == REDIS_ENCODING_ZIPLIST) {
281 unsigned char *zl;
282 unsigned char *fptr, *vptr;
283
284 zl = hi->subject->ptr;
285 fptr = hi->fptr;
286 vptr = hi->vptr;
287
288 if (fptr == NULL) {
289 /* Initialize cursor */
290 redisAssert(vptr == NULL);
291 fptr = ziplistIndex(zl, 0);
292 } else {
293 /* Advance cursor */
294 redisAssert(vptr != NULL);
295 fptr = ziplistNext(zl, vptr);
296 }
297 if (fptr == NULL) return REDIS_ERR;
298
299 /* Grab pointer to the value (fptr points to the field) */
300 vptr = ziplistNext(zl, fptr);
301 redisAssert(vptr != NULL);
302
303 /* fptr, vptr now point to the first or next pair */
304 hi->fptr = fptr;
305 hi->vptr = vptr;
306 } else if (hi->encoding == REDIS_ENCODING_HT) {
307 if ((hi->de = dictNext(hi->di)) == NULL) return REDIS_ERR;
308 } else {
309 redisPanic("Unknown hash encoding");
310 }
311 return REDIS_OK;
312 }
313
314 /* Get the field or value at iterator cursor, for an iterator on a hash value
315 * encoded as a ziplist. Prototype is similar to `hashTypeGetFromZiplist`. */
316 void hashTypeCurrentFromZiplist(hashTypeIterator *hi, int what,
317 unsigned char **vstr,
318 unsigned int *vlen,
319 long long *vll)
320 {
321 int ret;
322
323 redisAssert(hi->encoding == REDIS_ENCODING_ZIPLIST);
324
325 if (what & REDIS_HASH_KEY) {
326 ret = ziplistGet(hi->fptr, vstr, vlen, vll);
327 redisAssert(ret);
328 } else {
329 ret = ziplistGet(hi->vptr, vstr, vlen, vll);
330 redisAssert(ret);
331 }
332 }
333
334 /* Get the field or value at iterator cursor, for an iterator on a hash value
335 * encoded as a ziplist. Prototype is similar to `hashTypeGetFromHashTable`. */
336 void hashTypeCurrentFromHashTable(hashTypeIterator *hi, int what, robj **dst) {
337 redisAssert(hi->encoding == REDIS_ENCODING_HT);
338
339 if (what & REDIS_HASH_KEY) {
340 *dst = dictGetKey(hi->de);
341 } else {
342 *dst = dictGetVal(hi->de);
343 }
344 }
345
346 /* A non copy-on-write friendly but higher level version of hashTypeCurrent*()
347 * that returns an object with incremented refcount (or a new object). It is up
348 * to the caller to decrRefCount() the object if no reference is retained. */
349 robj *hashTypeCurrentObject(hashTypeIterator *hi, int what) {
350 robj *dst;
351
352 if (hi->encoding == REDIS_ENCODING_ZIPLIST) {
353 unsigned char *vstr = NULL;
354 unsigned int vlen = UINT_MAX;
355 long long vll = LLONG_MAX;
356
357 hashTypeCurrentFromZiplist(hi, what, &vstr, &vlen, &vll);
358 if (vstr) {
359 dst = createStringObject((char*)vstr, vlen);
360 } else {
361 dst = createStringObjectFromLongLong(vll);
362 }
363
364 } else if (hi->encoding == REDIS_ENCODING_HT) {
365 hashTypeCurrentFromHashTable(hi, what, &dst);
366 incrRefCount(dst);
367
368 } else {
369 redisPanic("Unknown hash encoding");
370 }
371
372 return dst;
373 }
374
375 robj *hashTypeLookupWriteOrCreate(redisClient *c, robj *key) {
376 robj *o = lookupKeyWrite(c->db,key);
377 if (o == NULL) {
378 o = createHashObject();
379 dbAdd(c->db,key,o);
380 } else {
381 if (o->type != REDIS_HASH) {
382 addReply(c,shared.wrongtypeerr);
383 return NULL;
384 }
385 }
386 return o;
387 }
388
389 void hashTypeConvertZiplist(robj *o, int enc) {
390 redisAssert(o->encoding == REDIS_ENCODING_ZIPLIST);
391
392 if (enc == REDIS_ENCODING_ZIPLIST) {
393 /* Nothing to do... */
394
395 } else if (enc == REDIS_ENCODING_HT) {
396 hashTypeIterator *hi;
397 dict *dict;
398 int ret;
399
400 hi = hashTypeInitIterator(o);
401 dict = dictCreate(&hashDictType, NULL);
402
403 while (hashTypeNext(hi) != REDIS_ERR) {
404 robj *field, *value;
405
406 field = hashTypeCurrentObject(hi, REDIS_HASH_KEY);
407 field = tryObjectEncoding(field);
408 value = hashTypeCurrentObject(hi, REDIS_HASH_VALUE);
409 value = tryObjectEncoding(value);
410 ret = dictAdd(dict, field, value);
411 redisAssert(ret == DICT_OK);
412 }
413
414 hashTypeReleaseIterator(hi);
415 zfree(o->ptr);
416
417 o->encoding = REDIS_ENCODING_HT;
418 o->ptr = dict;
419
420 } else {
421 redisPanic("Unknown hash encoding");
422 }
423 }
424
425 void hashTypeConvert(robj *o, int enc) {
426 if (o->encoding == REDIS_ENCODING_ZIPLIST) {
427 hashTypeConvertZiplist(o, enc);
428 } else if (o->encoding == REDIS_ENCODING_HT) {
429 redisPanic("Not implemented");
430 } else {
431 redisPanic("Unknown hash encoding");
432 }
433 }
434
435 /*-----------------------------------------------------------------------------
436 * Hash type commands
437 *----------------------------------------------------------------------------*/
438
439 void hsetCommand(redisClient *c) {
440 int update;
441 robj *o;
442
443 if ((o = hashTypeLookupWriteOrCreate(c,c->argv[1])) == NULL) return;
444 hashTypeTryConversion(o,c->argv,2,3);
445 hashTypeTryObjectEncoding(o,&c->argv[2], &c->argv[3]);
446 update = hashTypeSet(o,c->argv[2],c->argv[3]);
447 addReply(c, update ? shared.czero : shared.cone);
448 signalModifiedKey(c->db,c->argv[1]);
449 server.dirty++;
450 }
451
452 void hsetnxCommand(redisClient *c) {
453 robj *o;
454 if ((o = hashTypeLookupWriteOrCreate(c,c->argv[1])) == NULL) return;
455 hashTypeTryConversion(o,c->argv,2,3);
456
457 if (hashTypeExists(o, c->argv[2])) {
458 addReply(c, shared.czero);
459 } else {
460 hashTypeTryObjectEncoding(o,&c->argv[2], &c->argv[3]);
461 hashTypeSet(o,c->argv[2],c->argv[3]);
462 addReply(c, shared.cone);
463 signalModifiedKey(c->db,c->argv[1]);
464 server.dirty++;
465 }
466 }
467
468 void hmsetCommand(redisClient *c) {
469 int i;
470 robj *o;
471
472 if ((c->argc % 2) == 1) {
473 addReplyError(c,"wrong number of arguments for HMSET");
474 return;
475 }
476
477 if ((o = hashTypeLookupWriteOrCreate(c,c->argv[1])) == NULL) return;
478 hashTypeTryConversion(o,c->argv,2,c->argc-1);
479 for (i = 2; i < c->argc; i += 2) {
480 hashTypeTryObjectEncoding(o,&c->argv[i], &c->argv[i+1]);
481 hashTypeSet(o,c->argv[i],c->argv[i+1]);
482 }
483 addReply(c, shared.ok);
484 signalModifiedKey(c->db,c->argv[1]);
485 server.dirty++;
486 }
487
488 void hincrbyCommand(redisClient *c) {
489 long long value, incr, oldvalue;
490 robj *o, *current, *new;
491
492 if (getLongLongFromObjectOrReply(c,c->argv[3],&incr,NULL) != REDIS_OK) return;
493 if ((o = hashTypeLookupWriteOrCreate(c,c->argv[1])) == NULL) return;
494 if ((current = hashTypeGetObject(o,c->argv[2])) != NULL) {
495 if (getLongLongFromObjectOrReply(c,current,&value,
496 "hash value is not an integer") != REDIS_OK) {
497 decrRefCount(current);
498 return;
499 }
500 decrRefCount(current);
501 } else {
502 value = 0;
503 }
504
505 oldvalue = value;
506 if ((incr < 0 && oldvalue < 0 && incr < (LLONG_MIN-oldvalue)) ||
507 (incr > 0 && oldvalue > 0 && incr > (LLONG_MAX-oldvalue))) {
508 addReplyError(c,"increment or decrement would overflow");
509 return;
510 }
511 value += incr;
512 new = createStringObjectFromLongLong(value);
513 hashTypeTryObjectEncoding(o,&c->argv[2],NULL);
514 hashTypeSet(o,c->argv[2],new);
515 decrRefCount(new);
516 addReplyLongLong(c,value);
517 signalModifiedKey(c->db,c->argv[1]);
518 server.dirty++;
519 }
520
521 void hincrbyfloatCommand(redisClient *c) {
522 double long value, incr;
523 robj *o, *current, *new;
524
525 if (getLongDoubleFromObjectOrReply(c,c->argv[3],&incr,NULL) != REDIS_OK) return;
526 if ((o = hashTypeLookupWriteOrCreate(c,c->argv[1])) == NULL) return;
527 if ((current = hashTypeGetObject(o,c->argv[2])) != NULL) {
528 if (getLongDoubleFromObjectOrReply(c,current,&value,
529 "hash value is not a valid float") != REDIS_OK) {
530 decrRefCount(current);
531 return;
532 }
533 decrRefCount(current);
534 } else {
535 value = 0;
536 }
537
538 value += incr;
539 new = createStringObjectFromLongDouble(value);
540 hashTypeTryObjectEncoding(o,&c->argv[2],NULL);
541 hashTypeSet(o,c->argv[2],new);
542 addReplyBulk(c,new);
543 decrRefCount(new);
544 signalModifiedKey(c->db,c->argv[1]);
545 server.dirty++;
546 }
547
548 static void addHashFieldToReply(redisClient *c, robj *o, robj *field) {
549 int ret;
550
551 if (o == NULL) {
552 addReply(c, shared.nullbulk);
553 return;
554 }
555
556 if (o->encoding == REDIS_ENCODING_ZIPLIST) {
557 unsigned char *vstr = NULL;
558 unsigned int vlen = UINT_MAX;
559 long long vll = LLONG_MAX;
560
561 ret = hashTypeGetFromZiplist(o, field, &vstr, &vlen, &vll);
562 if (ret < 0) {
563 addReply(c, shared.nullbulk);
564 } else {
565 if (vstr) {
566 addReplyBulkCBuffer(c, vstr, vlen);
567 } else {
568 addReplyBulkLongLong(c, vll);
569 }
570 }
571
572 } else if (o->encoding == REDIS_ENCODING_HT) {
573 robj *value;
574
575 ret = hashTypeGetFromHashTable(o, field, &value);
576 if (ret < 0) {
577 addReply(c, shared.nullbulk);
578 } else {
579 addReplyBulk(c, value);
580 }
581
582 } else {
583 redisPanic("Unknown hash encoding");
584 }
585 }
586
587 void hgetCommand(redisClient *c) {
588 robj *o;
589
590 if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
591 checkType(c,o,REDIS_HASH)) return;
592
593 addHashFieldToReply(c, o, c->argv[2]);
594 }
595
596 void hmgetCommand(redisClient *c) {
597 robj *o;
598 int i;
599
600 /* Don't abort when the key cannot be found. Non-existing keys are empty
601 * hashes, where HMGET should respond with a series of null bulks. */
602 o = lookupKeyRead(c->db, c->argv[1]);
603 if (o != NULL && o->type != REDIS_HASH) {
604 addReply(c, shared.wrongtypeerr);
605 return;
606 }
607
608 addReplyMultiBulkLen(c, c->argc-2);
609 for (i = 2; i < c->argc; i++) {
610 addHashFieldToReply(c, o, c->argv[i]);
611 }
612 }
613
614 void hdelCommand(redisClient *c) {
615 robj *o;
616 int j, deleted = 0;
617
618 if ((o = lookupKeyWriteOrReply(c,c->argv[1],shared.czero)) == NULL ||
619 checkType(c,o,REDIS_HASH)) return;
620
621 for (j = 2; j < c->argc; j++) {
622 if (hashTypeDelete(o,c->argv[j])) {
623 deleted++;
624 if (hashTypeLength(o) == 0) {
625 dbDelete(c->db,c->argv[1]);
626 break;
627 }
628 }
629 }
630 if (deleted) {
631 signalModifiedKey(c->db,c->argv[1]);
632 server.dirty += deleted;
633 }
634 addReplyLongLong(c,deleted);
635 }
636
637 void hlenCommand(redisClient *c) {
638 robj *o;
639 if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
640 checkType(c,o,REDIS_HASH)) return;
641
642 addReplyLongLong(c,hashTypeLength(o));
643 }
644
645 static void addHashIteratorCursorToReply(redisClient *c, hashTypeIterator *hi, int what) {
646 if (hi->encoding == REDIS_ENCODING_ZIPLIST) {
647 unsigned char *vstr = NULL;
648 unsigned int vlen = UINT_MAX;
649 long long vll = LLONG_MAX;
650
651 hashTypeCurrentFromZiplist(hi, what, &vstr, &vlen, &vll);
652 if (vstr) {
653 addReplyBulkCBuffer(c, vstr, vlen);
654 } else {
655 addReplyBulkLongLong(c, vll);
656 }
657
658 } else if (hi->encoding == REDIS_ENCODING_HT) {
659 robj *value;
660
661 hashTypeCurrentFromHashTable(hi, what, &value);
662 addReplyBulk(c, value);
663
664 } else {
665 redisPanic("Unknown hash encoding");
666 }
667 }
668
669 void genericHgetallCommand(redisClient *c, int flags) {
670 robj *o;
671 hashTypeIterator *hi;
672 int multiplier = 0;
673 int length, count = 0;
674
675 if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.emptymultibulk)) == NULL
676 || checkType(c,o,REDIS_HASH)) return;
677
678 if (flags & REDIS_HASH_KEY) multiplier++;
679 if (flags & REDIS_HASH_VALUE) multiplier++;
680
681 length = hashTypeLength(o) * multiplier;
682 addReplyMultiBulkLen(c, length);
683
684 hi = hashTypeInitIterator(o);
685 while (hashTypeNext(hi) != REDIS_ERR) {
686 if (flags & REDIS_HASH_KEY) {
687 addHashIteratorCursorToReply(c, hi, REDIS_HASH_KEY);
688 count++;
689 }
690 if (flags & REDIS_HASH_VALUE) {
691 addHashIteratorCursorToReply(c, hi, REDIS_HASH_VALUE);
692 count++;
693 }
694 }
695
696 hashTypeReleaseIterator(hi);
697 redisAssert(count == length);
698 }
699
700 void hkeysCommand(redisClient *c) {
701 genericHgetallCommand(c,REDIS_HASH_KEY);
702 }
703
704 void hvalsCommand(redisClient *c) {
705 genericHgetallCommand(c,REDIS_HASH_VALUE);
706 }
707
708 void hgetallCommand(redisClient *c) {
709 genericHgetallCommand(c,REDIS_HASH_KEY|REDIS_HASH_VALUE);
710 }
711
712 void hexistsCommand(redisClient *c) {
713 robj *o;
714 if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
715 checkType(c,o,REDIS_HASH)) return;
716
717 addReply(c, hashTypeExists(o,c->argv[2]) ? shared.cone : shared.czero);
718 }
Redis += OpenLDAP MDB