]>
Commit | Line | Data |
---|---|---|
e2641e09 | 1 | #include "redis.h" |
2 | ||
3 | /*----------------------------------------------------------------------------- | |
4 | * Set Commands | |
5 | *----------------------------------------------------------------------------*/ | |
6 | ||
96ffb2fe PN |
7 | /* Factory method to return a set that *can* hold "value". When the object has |
8 | * an integer-encodable value, an intset will be returned. Otherwise a regular | |
9 | * hash table. */ | |
10 | robj *setTypeCreate(robj *value) { | |
ec7e1389 | 11 | if (isObjectRepresentableAsLongLong(value,NULL) == REDIS_OK) |
96ffb2fe PN |
12 | return createIntsetObject(); |
13 | return createSetObject(); | |
14 | } | |
15 | ||
16 | int setTypeAdd(robj *subject, robj *value) { | |
17 | long long llval; | |
18 | if (subject->encoding == REDIS_ENCODING_HT) { | |
19 | if (dictAdd(subject->ptr,value,NULL) == DICT_OK) { | |
20 | incrRefCount(value); | |
21 | return 1; | |
22 | } | |
23 | } else if (subject->encoding == REDIS_ENCODING_INTSET) { | |
ec7e1389 | 24 | if (isObjectRepresentableAsLongLong(value,&llval) == REDIS_OK) { |
96ffb2fe PN |
25 | uint8_t success = 0; |
26 | subject->ptr = intsetAdd(subject->ptr,llval,&success); | |
27 | if (success) { | |
28 | /* Convert to regular set when the intset contains | |
29 | * too many entries. */ | |
30 | if (intsetLen(subject->ptr) > server.set_max_intset_entries) | |
31 | setTypeConvert(subject,REDIS_ENCODING_HT); | |
32 | return 1; | |
33 | } | |
34 | } else { | |
35 | /* Failed to get integer from object, convert to regular set. */ | |
36 | setTypeConvert(subject,REDIS_ENCODING_HT); | |
37 | ||
38 | /* The set *was* an intset and this value is not integer | |
39 | * encodable, so dictAdd should always work. */ | |
40 | redisAssert(dictAdd(subject->ptr,value,NULL) == DICT_OK); | |
41 | incrRefCount(value); | |
42 | return 1; | |
43 | } | |
44 | } else { | |
45 | redisPanic("Unknown set encoding"); | |
46 | } | |
47 | return 0; | |
48 | } | |
49 | ||
a5be65f7 | 50 | int setTypeRemove(robj *setobj, robj *value) { |
96ffb2fe | 51 | long long llval; |
a5be65f7 | 52 | if (setobj->encoding == REDIS_ENCODING_HT) { |
53 | if (dictDelete(setobj->ptr,value) == DICT_OK) { | |
54 | if (htNeedsResize(setobj->ptr)) dictResize(setobj->ptr); | |
96ffb2fe PN |
55 | return 1; |
56 | } | |
a5be65f7 | 57 | } else if (setobj->encoding == REDIS_ENCODING_INTSET) { |
ec7e1389 | 58 | if (isObjectRepresentableAsLongLong(value,&llval) == REDIS_OK) { |
a5be65f7 | 59 | int success; |
60 | setobj->ptr = intsetRemove(setobj->ptr,llval,&success); | |
96ffb2fe PN |
61 | if (success) return 1; |
62 | } | |
63 | } else { | |
64 | redisPanic("Unknown set encoding"); | |
65 | } | |
66 | return 0; | |
67 | } | |
68 | ||
69 | int setTypeIsMember(robj *subject, robj *value) { | |
70 | long long llval; | |
71 | if (subject->encoding == REDIS_ENCODING_HT) { | |
72 | return dictFind((dict*)subject->ptr,value) != NULL; | |
73 | } else if (subject->encoding == REDIS_ENCODING_INTSET) { | |
ec7e1389 | 74 | if (isObjectRepresentableAsLongLong(value,&llval) == REDIS_OK) { |
96ffb2fe PN |
75 | return intsetFind((intset*)subject->ptr,llval); |
76 | } | |
77 | } else { | |
78 | redisPanic("Unknown set encoding"); | |
79 | } | |
80 | return 0; | |
81 | } | |
82 | ||
cb72d0f1 | 83 | setTypeIterator *setTypeInitIterator(robj *subject) { |
740eee1c | 84 | setTypeIterator *si = zmalloc(sizeof(setTypeIterator)); |
96ffb2fe PN |
85 | si->subject = subject; |
86 | si->encoding = subject->encoding; | |
87 | if (si->encoding == REDIS_ENCODING_HT) { | |
88 | si->di = dictGetIterator(subject->ptr); | |
89 | } else if (si->encoding == REDIS_ENCODING_INTSET) { | |
90 | si->ii = 0; | |
91 | } else { | |
92 | redisPanic("Unknown set encoding"); | |
93 | } | |
94 | return si; | |
95 | } | |
96 | ||
cb72d0f1 | 97 | void setTypeReleaseIterator(setTypeIterator *si) { |
96ffb2fe PN |
98 | if (si->encoding == REDIS_ENCODING_HT) |
99 | dictReleaseIterator(si->di); | |
100 | zfree(si); | |
101 | } | |
102 | ||
103 | /* Move to the next entry in the set. Returns the object at the current | |
1b508da7 | 104 | * position. |
105 | * | |
106 | * Since set elements can be internally be stored as redis objects or | |
107 | * simple arrays of integers, setTypeNext returns the encoding of the | |
108 | * set object you are iterating, and will populate the appropriate pointer | |
109 | * (eobj) or (llobj) accordingly. | |
110 | * | |
111 | * When there are no longer elements -1 is returned. | |
112 | * Returned objects ref count is not incremented, so this function is | |
113 | * copy on write friendly. */ | |
114 | int setTypeNext(setTypeIterator *si, robj **objele, int64_t *llele) { | |
96ffb2fe PN |
115 | if (si->encoding == REDIS_ENCODING_HT) { |
116 | dictEntry *de = dictNext(si->di); | |
1b508da7 | 117 | if (de == NULL) return -1; |
118 | *objele = dictGetEntryKey(de); | |
96ffb2fe | 119 | } else if (si->encoding == REDIS_ENCODING_INTSET) { |
1b508da7 | 120 | if (!intsetGet(si->subject->ptr,si->ii++,llele)) |
121 | return -1; | |
96ffb2fe | 122 | } |
1b508da7 | 123 | return si->encoding; |
96ffb2fe PN |
124 | } |
125 | ||
1b508da7 | 126 | /* The not copy on write friendly version but easy to use version |
127 | * of setTypeNext() is setTypeNextObject(), returning new objects | |
128 | * or incrementing the ref count of returned objects. So if you don't | |
129 | * retain a pointer to this object you should call decrRefCount() against it. | |
130 | * | |
131 | * This function is the way to go for write operations where COW is not | |
132 | * an issue as the result will be anyway of incrementing the ref count. */ | |
133 | robj *setTypeNextObject(setTypeIterator *si) { | |
134 | int64_t intele; | |
135 | robj *objele; | |
136 | int encoding; | |
137 | ||
138 | encoding = setTypeNext(si,&objele,&intele); | |
139 | switch(encoding) { | |
140 | case -1: return NULL; | |
141 | case REDIS_ENCODING_INTSET: | |
142 | return createStringObjectFromLongLong(intele); | |
143 | case REDIS_ENCODING_HT: | |
144 | incrRefCount(objele); | |
145 | return objele; | |
146 | default: | |
147 | redisPanic("Unsupported encoding"); | |
148 | } | |
149 | return NULL; /* just to suppress warnings */ | |
150 | } | |
96ffb2fe | 151 | |
a5be65f7 | 152 | /* Return random element from a non empty set. |
1b508da7 | 153 | * The returned element can be a int64_t value if the set is encoded |
a5be65f7 | 154 | * as an "intset" blob of integers, or a redis object if the set |
155 | * is a regular set. | |
156 | * | |
157 | * The caller provides both pointers to be populated with the right | |
158 | * object. The return value of the function is the object->encoding | |
159 | * field of the object and is used by the caller to check if the | |
1b508da7 | 160 | * int64_t pointer or the redis object pointere was populated. |
a5be65f7 | 161 | * |
162 | * When an object is returned (the set was a real set) the ref count | |
163 | * of the object is not incremented so this function can be considered | |
1b508da7 | 164 | * copy on write friendly. */ |
165 | int setTypeRandomElement(robj *setobj, robj **objele, int64_t *llele) { | |
a5be65f7 | 166 | if (setobj->encoding == REDIS_ENCODING_HT) { |
167 | dictEntry *de = dictGetRandomKey(setobj->ptr); | |
168 | *objele = dictGetEntryKey(de); | |
169 | } else if (setobj->encoding == REDIS_ENCODING_INTSET) { | |
170 | *llele = intsetRandom(setobj->ptr); | |
96ffb2fe PN |
171 | } else { |
172 | redisPanic("Unknown set encoding"); | |
173 | } | |
a5be65f7 | 174 | return setobj->encoding; |
96ffb2fe PN |
175 | } |
176 | ||
177 | unsigned long setTypeSize(robj *subject) { | |
178 | if (subject->encoding == REDIS_ENCODING_HT) { | |
179 | return dictSize((dict*)subject->ptr); | |
180 | } else if (subject->encoding == REDIS_ENCODING_INTSET) { | |
181 | return intsetLen((intset*)subject->ptr); | |
182 | } else { | |
183 | redisPanic("Unknown set encoding"); | |
184 | } | |
185 | } | |
186 | ||
187 | /* Convert the set to specified encoding. The resulting dict (when converting | |
188 | * to a hashtable) is presized to hold the number of elements in the original | |
189 | * set. */ | |
1b508da7 | 190 | void setTypeConvert(robj *setobj, int enc) { |
cb72d0f1 | 191 | setTypeIterator *si; |
1b508da7 | 192 | redisAssert(setobj->type == REDIS_SET && |
193 | setobj->encoding == REDIS_ENCODING_INTSET); | |
96ffb2fe PN |
194 | |
195 | if (enc == REDIS_ENCODING_HT) { | |
1b508da7 | 196 | int64_t intele; |
96ffb2fe | 197 | dict *d = dictCreate(&setDictType,NULL); |
1b508da7 | 198 | robj *element; |
199 | ||
96ffb2fe | 200 | /* Presize the dict to avoid rehashing */ |
1b508da7 | 201 | dictExpand(d,intsetLen(setobj->ptr)); |
96ffb2fe | 202 | |
1b508da7 | 203 | /* To add the elements we extract integers and create redis objects */ |
204 | si = setTypeInitIterator(setobj); | |
205 | while (setTypeNext(si,NULL,&intele) != -1) { | |
206 | element = createStringObjectFromLongLong(intele); | |
96ffb2fe | 207 | redisAssert(dictAdd(d,element,NULL) == DICT_OK); |
1b508da7 | 208 | } |
96ffb2fe PN |
209 | setTypeReleaseIterator(si); |
210 | ||
1b508da7 | 211 | setobj->encoding = REDIS_ENCODING_HT; |
212 | zfree(setobj->ptr); | |
213 | setobj->ptr = d; | |
96ffb2fe PN |
214 | } else { |
215 | redisPanic("Unsupported set conversion"); | |
216 | } | |
217 | } | |
218 | ||
e2641e09 | 219 | void saddCommand(redisClient *c) { |
220 | robj *set; | |
221 | ||
222 | set = lookupKeyWrite(c->db,c->argv[1]); | |
75b41de8 | 223 | c->argv[2] = tryObjectEncoding(c->argv[2]); |
e2641e09 | 224 | if (set == NULL) { |
96ffb2fe | 225 | set = setTypeCreate(c->argv[2]); |
e2641e09 | 226 | dbAdd(c->db,c->argv[1],set); |
227 | } else { | |
228 | if (set->type != REDIS_SET) { | |
229 | addReply(c,shared.wrongtypeerr); | |
230 | return; | |
231 | } | |
232 | } | |
96ffb2fe | 233 | if (setTypeAdd(set,c->argv[2])) { |
5b4bff9c | 234 | touchWatchedKey(c->db,c->argv[1]); |
e2641e09 | 235 | server.dirty++; |
236 | addReply(c,shared.cone); | |
237 | } else { | |
238 | addReply(c,shared.czero); | |
239 | } | |
240 | } | |
241 | ||
242 | void sremCommand(redisClient *c) { | |
243 | robj *set; | |
244 | ||
245 | if ((set = lookupKeyWriteOrReply(c,c->argv[1],shared.czero)) == NULL || | |
246 | checkType(c,set,REDIS_SET)) return; | |
247 | ||
75b41de8 | 248 | c->argv[2] = tryObjectEncoding(c->argv[2]); |
96ffb2fe PN |
249 | if (setTypeRemove(set,c->argv[2])) { |
250 | if (setTypeSize(set) == 0) dbDelete(c->db,c->argv[1]); | |
5b4bff9c | 251 | touchWatchedKey(c->db,c->argv[1]); |
e2641e09 | 252 | server.dirty++; |
e2641e09 | 253 | addReply(c,shared.cone); |
254 | } else { | |
255 | addReply(c,shared.czero); | |
256 | } | |
257 | } | |
258 | ||
259 | void smoveCommand(redisClient *c) { | |
96ffb2fe | 260 | robj *srcset, *dstset, *ele; |
e2641e09 | 261 | srcset = lookupKeyWrite(c->db,c->argv[1]); |
262 | dstset = lookupKeyWrite(c->db,c->argv[2]); | |
75b41de8 | 263 | ele = c->argv[3] = tryObjectEncoding(c->argv[3]); |
e2641e09 | 264 | |
96ffb2fe PN |
265 | /* If the source key does not exist return 0 */ |
266 | if (srcset == NULL) { | |
267 | addReply(c,shared.czero); | |
e2641e09 | 268 | return; |
269 | } | |
96ffb2fe PN |
270 | |
271 | /* If the source key has the wrong type, or the destination key | |
272 | * is set and has the wrong type, return with an error. */ | |
273 | if (checkType(c,srcset,REDIS_SET) || | |
274 | (dstset && checkType(c,dstset,REDIS_SET))) return; | |
275 | ||
276 | /* If srcset and dstset are equal, SMOVE is a no-op */ | |
277 | if (srcset == dstset) { | |
278 | addReply(c,shared.cone); | |
e2641e09 | 279 | return; |
280 | } | |
96ffb2fe PN |
281 | |
282 | /* If the element cannot be removed from the src set, return 0. */ | |
283 | if (!setTypeRemove(srcset,ele)) { | |
e2641e09 | 284 | addReply(c,shared.czero); |
285 | return; | |
286 | } | |
96ffb2fe PN |
287 | |
288 | /* Remove the src set from the database when empty */ | |
289 | if (setTypeSize(srcset) == 0) dbDelete(c->db,c->argv[1]); | |
5b4bff9c | 290 | touchWatchedKey(c->db,c->argv[1]); |
291 | touchWatchedKey(c->db,c->argv[2]); | |
e2641e09 | 292 | server.dirty++; |
96ffb2fe PN |
293 | |
294 | /* Create the destination set when it doesn't exist */ | |
e2641e09 | 295 | if (!dstset) { |
96ffb2fe | 296 | dstset = setTypeCreate(ele); |
e2641e09 | 297 | dbAdd(c->db,c->argv[2],dstset); |
298 | } | |
96ffb2fe PN |
299 | |
300 | /* An extra key has changed when ele was successfully added to dstset */ | |
301 | if (setTypeAdd(dstset,ele)) server.dirty++; | |
e2641e09 | 302 | addReply(c,shared.cone); |
303 | } | |
304 | ||
305 | void sismemberCommand(redisClient *c) { | |
306 | robj *set; | |
307 | ||
308 | if ((set = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL || | |
309 | checkType(c,set,REDIS_SET)) return; | |
310 | ||
75b41de8 | 311 | c->argv[2] = tryObjectEncoding(c->argv[2]); |
96ffb2fe | 312 | if (setTypeIsMember(set,c->argv[2])) |
e2641e09 | 313 | addReply(c,shared.cone); |
314 | else | |
315 | addReply(c,shared.czero); | |
316 | } | |
317 | ||
318 | void scardCommand(redisClient *c) { | |
319 | robj *o; | |
e2641e09 | 320 | |
321 | if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL || | |
322 | checkType(c,o,REDIS_SET)) return; | |
323 | ||
b70d3555 | 324 | addReplyLongLong(c,setTypeSize(o)); |
e2641e09 | 325 | } |
326 | ||
327 | void spopCommand(redisClient *c) { | |
96ffb2fe | 328 | robj *set, *ele; |
1b508da7 | 329 | int64_t llele; |
a5be65f7 | 330 | int encoding; |
e2641e09 | 331 | |
332 | if ((set = lookupKeyWriteOrReply(c,c->argv[1],shared.nullbulk)) == NULL || | |
333 | checkType(c,set,REDIS_SET)) return; | |
334 | ||
a5be65f7 | 335 | encoding = setTypeRandomElement(set,&ele,&llele); |
336 | if (encoding == REDIS_ENCODING_INTSET) { | |
337 | addReplyBulkLongLong(c,llele); | |
338 | set->ptr = intsetRemove(set->ptr,llele,NULL); | |
e2641e09 | 339 | } else { |
e2641e09 | 340 | addReplyBulk(c,ele); |
a5be65f7 | 341 | setTypeRemove(set,ele); |
e2641e09 | 342 | } |
a5be65f7 | 343 | if (setTypeSize(set) == 0) dbDelete(c->db,c->argv[1]); |
344 | touchWatchedKey(c->db,c->argv[1]); | |
345 | server.dirty++; | |
e2641e09 | 346 | } |
347 | ||
348 | void srandmemberCommand(redisClient *c) { | |
96ffb2fe | 349 | robj *set, *ele; |
1b508da7 | 350 | int64_t llele; |
a5be65f7 | 351 | int encoding; |
e2641e09 | 352 | |
353 | if ((set = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL || | |
354 | checkType(c,set,REDIS_SET)) return; | |
355 | ||
a5be65f7 | 356 | encoding = setTypeRandomElement(set,&ele,&llele); |
357 | if (encoding == REDIS_ENCODING_INTSET) { | |
358 | addReplyBulkLongLong(c,llele); | |
e2641e09 | 359 | } else { |
e2641e09 | 360 | addReplyBulk(c,ele); |
361 | } | |
362 | } | |
363 | ||
364 | int qsortCompareSetsByCardinality(const void *s1, const void *s2) { | |
96ffb2fe | 365 | return setTypeSize(*(robj**)s1)-setTypeSize(*(robj**)s2); |
e2641e09 | 366 | } |
367 | ||
96ffb2fe PN |
368 | void sinterGenericCommand(redisClient *c, robj **setkeys, unsigned long setnum, robj *dstkey) { |
369 | robj **sets = zmalloc(sizeof(robj*)*setnum); | |
cb72d0f1 | 370 | setTypeIterator *si; |
1b508da7 | 371 | robj *eleobj, *dstset = NULL; |
372 | int64_t intobj; | |
b301c1fc | 373 | void *replylen = NULL; |
e2641e09 | 374 | unsigned long j, cardinality = 0; |
1b508da7 | 375 | int encoding; |
e2641e09 | 376 | |
96ffb2fe PN |
377 | for (j = 0; j < setnum; j++) { |
378 | robj *setobj = dstkey ? | |
379 | lookupKeyWrite(c->db,setkeys[j]) : | |
380 | lookupKeyRead(c->db,setkeys[j]); | |
e2641e09 | 381 | if (!setobj) { |
96ffb2fe | 382 | zfree(sets); |
e2641e09 | 383 | if (dstkey) { |
5b4bff9c | 384 | if (dbDelete(c->db,dstkey)) { |
385 | touchWatchedKey(c->db,dstkey); | |
e2641e09 | 386 | server.dirty++; |
5b4bff9c | 387 | } |
e2641e09 | 388 | addReply(c,shared.czero); |
389 | } else { | |
390 | addReply(c,shared.emptymultibulk); | |
391 | } | |
392 | return; | |
393 | } | |
96ffb2fe PN |
394 | if (checkType(c,setobj,REDIS_SET)) { |
395 | zfree(sets); | |
e2641e09 | 396 | return; |
397 | } | |
96ffb2fe | 398 | sets[j] = setobj; |
e2641e09 | 399 | } |
400 | /* Sort sets from the smallest to largest, this will improve our | |
401 | * algorithm's performace */ | |
96ffb2fe | 402 | qsort(sets,setnum,sizeof(robj*),qsortCompareSetsByCardinality); |
e2641e09 | 403 | |
404 | /* The first thing we should output is the total number of elements... | |
405 | * since this is a multi-bulk write, but at this stage we don't know | |
406 | * the intersection set size, so we use a trick, append an empty object | |
407 | * to the output list and save the pointer to later modify it with the | |
408 | * right length */ | |
409 | if (!dstkey) { | |
b301c1fc | 410 | replylen = addDeferredMultiBulkLength(c); |
e2641e09 | 411 | } else { |
412 | /* If we have a target key where to store the resulting set | |
413 | * create this key with an empty set inside */ | |
96ffb2fe | 414 | dstset = createIntsetObject(); |
e2641e09 | 415 | } |
416 | ||
417 | /* Iterate all the elements of the first (smallest) set, and test | |
418 | * the element against all the other sets, if at least one set does | |
419 | * not include the element it is discarded */ | |
96ffb2fe | 420 | si = setTypeInitIterator(sets[0]); |
1b508da7 | 421 | while((encoding = setTypeNext(si,&eleobj,&intobj)) != -1) { |
422 | for (j = 1; j < setnum; j++) { | |
423 | if (encoding == REDIS_ENCODING_INTSET) { | |
424 | /* intset with intset is simple... and fast */ | |
425 | if (sets[j]->encoding == REDIS_ENCODING_INTSET && | |
426 | !intsetFind((intset*)sets[j]->ptr,intobj)) | |
427 | { | |
428 | break; | |
429 | /* in order to compare an integer with an object we | |
430 | * have to use the generic function, creating an object | |
431 | * for this */ | |
432 | } else if (sets[j]->encoding == REDIS_ENCODING_HT) { | |
433 | eleobj = createStringObjectFromLongLong(intobj); | |
434 | if (!setTypeIsMember(sets[j],eleobj)) { | |
435 | decrRefCount(eleobj); | |
436 | break; | |
437 | } | |
438 | decrRefCount(eleobj); | |
439 | } | |
440 | } else if (encoding == REDIS_ENCODING_HT) { | |
441 | /* Optimization... if the source object is integer | |
442 | * encoded AND the target set is an intset, we can get | |
443 | * a much faster path. */ | |
444 | if (eleobj->encoding == REDIS_ENCODING_INT && | |
445 | sets[j]->encoding == REDIS_ENCODING_INTSET && | |
446 | !intsetFind((intset*)sets[j]->ptr,(long)eleobj->ptr)) | |
447 | { | |
448 | break; | |
449 | /* else... object to object check is easy as we use the | |
450 | * type agnostic API here. */ | |
451 | } else if (!setTypeIsMember(sets[j],eleobj)) { | |
452 | break; | |
453 | } | |
454 | } | |
455 | } | |
96ffb2fe PN |
456 | |
457 | /* Only take action when all sets contain the member */ | |
458 | if (j == setnum) { | |
459 | if (!dstkey) { | |
1b508da7 | 460 | if (encoding == REDIS_ENCODING_HT) |
461 | addReplyBulk(c,eleobj); | |
462 | else | |
463 | addReplyBulkLongLong(c,intobj); | |
96ffb2fe PN |
464 | cardinality++; |
465 | } else { | |
1b508da7 | 466 | if (encoding == REDIS_ENCODING_INTSET) { |
467 | eleobj = createStringObjectFromLongLong(intobj); | |
468 | setTypeAdd(dstset,eleobj); | |
469 | decrRefCount(eleobj); | |
470 | } else { | |
471 | setTypeAdd(dstset,eleobj); | |
472 | } | |
96ffb2fe | 473 | } |
e2641e09 | 474 | } |
475 | } | |
96ffb2fe | 476 | setTypeReleaseIterator(si); |
e2641e09 | 477 | |
478 | if (dstkey) { | |
479 | /* Store the resulting set into the target, if the intersection | |
480 | * is not an empty set. */ | |
481 | dbDelete(c->db,dstkey); | |
96ffb2fe | 482 | if (setTypeSize(dstset) > 0) { |
e2641e09 | 483 | dbAdd(c->db,dstkey,dstset); |
96ffb2fe | 484 | addReplyLongLong(c,setTypeSize(dstset)); |
e2641e09 | 485 | } else { |
486 | decrRefCount(dstset); | |
487 | addReply(c,shared.czero); | |
488 | } | |
5b4bff9c | 489 | touchWatchedKey(c->db,dstkey); |
e2641e09 | 490 | server.dirty++; |
491 | } else { | |
b301c1fc | 492 | setDeferredMultiBulkLength(c,replylen,cardinality); |
e2641e09 | 493 | } |
96ffb2fe | 494 | zfree(sets); |
e2641e09 | 495 | } |
496 | ||
497 | void sinterCommand(redisClient *c) { | |
498 | sinterGenericCommand(c,c->argv+1,c->argc-1,NULL); | |
499 | } | |
500 | ||
501 | void sinterstoreCommand(redisClient *c) { | |
502 | sinterGenericCommand(c,c->argv+2,c->argc-2,c->argv[1]); | |
503 | } | |
504 | ||
96ffb2fe PN |
505 | #define REDIS_OP_UNION 0 |
506 | #define REDIS_OP_DIFF 1 | |
507 | #define REDIS_OP_INTER 2 | |
e2641e09 | 508 | |
96ffb2fe PN |
509 | void sunionDiffGenericCommand(redisClient *c, robj **setkeys, int setnum, robj *dstkey, int op) { |
510 | robj **sets = zmalloc(sizeof(robj*)*setnum); | |
cb72d0f1 | 511 | setTypeIterator *si; |
96ffb2fe PN |
512 | robj *ele, *dstset = NULL; |
513 | int j, cardinality = 0; | |
e2641e09 | 514 | |
96ffb2fe PN |
515 | for (j = 0; j < setnum; j++) { |
516 | robj *setobj = dstkey ? | |
517 | lookupKeyWrite(c->db,setkeys[j]) : | |
518 | lookupKeyRead(c->db,setkeys[j]); | |
e2641e09 | 519 | if (!setobj) { |
96ffb2fe | 520 | sets[j] = NULL; |
e2641e09 | 521 | continue; |
522 | } | |
96ffb2fe PN |
523 | if (checkType(c,setobj,REDIS_SET)) { |
524 | zfree(sets); | |
e2641e09 | 525 | return; |
526 | } | |
96ffb2fe | 527 | sets[j] = setobj; |
e2641e09 | 528 | } |
529 | ||
530 | /* We need a temp set object to store our union. If the dstkey | |
531 | * is not NULL (that is, we are inside an SUNIONSTORE operation) then | |
532 | * this set object will be the resulting object to set into the target key*/ | |
96ffb2fe | 533 | dstset = createIntsetObject(); |
e2641e09 | 534 | |
535 | /* Iterate all the elements of all the sets, add every element a single | |
536 | * time to the result set */ | |
96ffb2fe PN |
537 | for (j = 0; j < setnum; j++) { |
538 | if (op == REDIS_OP_DIFF && j == 0 && !sets[j]) break; /* result set is empty */ | |
539 | if (!sets[j]) continue; /* non existing keys are like empty sets */ | |
e2641e09 | 540 | |
96ffb2fe | 541 | si = setTypeInitIterator(sets[j]); |
1b508da7 | 542 | while((ele = setTypeNextObject(si)) != NULL) { |
e2641e09 | 543 | if (op == REDIS_OP_UNION || j == 0) { |
96ffb2fe | 544 | if (setTypeAdd(dstset,ele)) { |
e2641e09 | 545 | cardinality++; |
546 | } | |
547 | } else if (op == REDIS_OP_DIFF) { | |
96ffb2fe | 548 | if (setTypeRemove(dstset,ele)) { |
e2641e09 | 549 | cardinality--; |
550 | } | |
551 | } | |
96ffb2fe | 552 | decrRefCount(ele); |
e2641e09 | 553 | } |
96ffb2fe | 554 | setTypeReleaseIterator(si); |
e2641e09 | 555 | |
96ffb2fe | 556 | /* Exit when result set is empty. */ |
e2641e09 | 557 | if (op == REDIS_OP_DIFF && cardinality == 0) break; |
558 | } | |
559 | ||
560 | /* Output the content of the resulting set, if not in STORE mode */ | |
561 | if (!dstkey) { | |
0537e7bf | 562 | addReplyMultiBulkLen(c,cardinality); |
96ffb2fe | 563 | si = setTypeInitIterator(dstset); |
1b508da7 | 564 | while((ele = setTypeNextObject(si)) != NULL) { |
e2641e09 | 565 | addReplyBulk(c,ele); |
96ffb2fe | 566 | decrRefCount(ele); |
e2641e09 | 567 | } |
96ffb2fe | 568 | setTypeReleaseIterator(si); |
e2641e09 | 569 | decrRefCount(dstset); |
570 | } else { | |
571 | /* If we have a target key where to store the resulting set | |
572 | * create this key with the result set inside */ | |
573 | dbDelete(c->db,dstkey); | |
96ffb2fe | 574 | if (setTypeSize(dstset) > 0) { |
e2641e09 | 575 | dbAdd(c->db,dstkey,dstset); |
96ffb2fe | 576 | addReplyLongLong(c,setTypeSize(dstset)); |
e2641e09 | 577 | } else { |
578 | decrRefCount(dstset); | |
579 | addReply(c,shared.czero); | |
580 | } | |
5b4bff9c | 581 | touchWatchedKey(c->db,dstkey); |
e2641e09 | 582 | server.dirty++; |
583 | } | |
96ffb2fe | 584 | zfree(sets); |
e2641e09 | 585 | } |
586 | ||
587 | void sunionCommand(redisClient *c) { | |
588 | sunionDiffGenericCommand(c,c->argv+1,c->argc-1,NULL,REDIS_OP_UNION); | |
589 | } | |
590 | ||
591 | void sunionstoreCommand(redisClient *c) { | |
592 | sunionDiffGenericCommand(c,c->argv+2,c->argc-2,c->argv[1],REDIS_OP_UNION); | |
593 | } | |
594 | ||
595 | void sdiffCommand(redisClient *c) { | |
596 | sunionDiffGenericCommand(c,c->argv+1,c->argc-1,NULL,REDIS_OP_DIFF); | |
597 | } | |
598 | ||
599 | void sdiffstoreCommand(redisClient *c) { | |
600 | sunionDiffGenericCommand(c,c->argv+2,c->argc-2,c->argv[1],REDIS_OP_DIFF); | |
601 | } |