+/*
+ * Copyright (c) 2009-2012, Salvatore Sanfilippo <antirez at gmail dot com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * * Neither the name of Redis nor the names of its contributors may be used
+ * to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
#include "redis.h"
#include <math.h>
zl = o->ptr;
fptr = ziplistIndex(zl, ZIPLIST_HEAD);
- while (fptr != NULL) {
- /* Grab pointer to the value (fptr points to the field) */
- vptr = ziplistNext(zl, fptr);
- redisAssert(vptr != NULL);
-
- /* Compare field in ziplist with specified field */
- if (ziplistCompare(fptr, field->ptr, sdslen(field->ptr))) {
- break;
+ if (fptr != NULL) {
+ fptr = ziplistFind(fptr, field->ptr, sdslen(field->ptr), 1);
+ if (fptr != NULL) {
+ /* Grab pointer to the value (fptr points to the field) */
+ vptr = ziplistNext(zl, fptr);
+ redisAssert(vptr != NULL);
}
-
- /* Skip over value */
- fptr = ziplistNext(zl, vptr);
}
decrRefCount(field);
- if (fptr != NULL) {
+ if (vptr != NULL) {
ret = ziplistGet(vptr, vstr, vlen, vll);
redisAssert(ret);
return 0;
redisAssert(o->encoding == REDIS_ENCODING_HT);
de = dictFind(o->ptr, field);
- if (de == NULL) {
- return -1;
- }
-
+ if (de == NULL) return -1;
*value = dictGetVal(de);
return 0;
}
incrRefCount(aux);
value = aux;
}
-
} else {
redisPanic("Unknown hash encoding");
}
-
return value;
}
unsigned int vlen = UINT_MAX;
long long vll = LLONG_MAX;
- if (hashTypeGetFromZiplist(o, field, &vstr, &vlen, &vll) == 0) {
- return 1;
- }
-
+ if (hashTypeGetFromZiplist(o, field, &vstr, &vlen, &vll) == 0) return 1;
} else if (o->encoding == REDIS_ENCODING_HT) {
robj *aux;
- if (hashTypeGetFromHashTable(o, field, &aux) == 0) {
- return 1;
- }
-
+ if (hashTypeGetFromHashTable(o, field, &aux) == 0) return 1;
} else {
redisPanic("Unknown hash encoding");
}
-
return 0;
}
/* Add an element, discard the old if the key already exists.
- * Return 0 on insert and 1 on update. */
+ * Return 0 on insert and 1 on update.
+ * This function will take care of incrementing the reference count of the
+ * retained fields and value objects. */
int hashTypeSet(robj *o, robj *field, robj *value) {
int update = 0;
zl = o->ptr;
fptr = ziplistIndex(zl, ZIPLIST_HEAD);
- while (fptr != NULL) {
- /* Compare field in ziplist with specified field */
- if (ziplistCompare(fptr, field->ptr, sdslen(field->ptr))) {
- zl = ziplistDelete(zl,&fptr);
- zl = ziplistDelete(zl,&fptr);
- o->ptr = zl;
+ if (fptr != NULL) {
+ fptr = ziplistFind(fptr, field->ptr, sdslen(field->ptr), 1);
+ if (fptr != NULL) {
+ /* Grab pointer to the value (fptr points to the field) */
+ vptr = ziplistNext(zl, fptr);
+ redisAssert(vptr != NULL);
update = 1;
- break;
- }
- /* Grab pointer to the value (fptr points to the field) */
- vptr = ziplistNext(zl, fptr);
- redisAssert(vptr != NULL);
+ /* Delete value */
+ zl = ziplistDelete(zl, &vptr);
- /* Grab pointer (if any) to the next field */
- fptr = ziplistNext(zl, vptr);
+ /* Insert new value */
+ zl = ziplistInsert(zl, vptr, value->ptr, sdslen(value->ptr));
+ }
}
- /* Push new field/value pair onto the tail of the ziplist */
- zl = ziplistPush(zl, field->ptr, sdslen(field->ptr), ZIPLIST_TAIL);
- zl = ziplistPush(zl, value->ptr, sdslen(value->ptr), ZIPLIST_TAIL);
+ if (!update) {
+ /* Push new field/value pair onto the tail of the ziplist */
+ zl = ziplistPush(zl, field->ptr, sdslen(field->ptr), ZIPLIST_TAIL);
+ zl = ziplistPush(zl, value->ptr, sdslen(value->ptr), ZIPLIST_TAIL);
+ }
o->ptr = zl;
-
decrRefCount(field);
decrRefCount(value);
/* Check if the ziplist needs to be converted to a hash table */
- if (hashTypeLength(o) > server.hash_max_ziplist_entries) {
+ if (hashTypeLength(o) > server.hash_max_ziplist_entries)
hashTypeConvert(o, REDIS_ENCODING_HT);
- }
-
} else if (o->encoding == REDIS_ENCODING_HT) {
if (dictReplace(o->ptr, field, value)) { /* Insert */
incrRefCount(field);
} else { /* Update */
update = 1;
}
-
incrRefCount(value);
-
} else {
redisPanic("Unknown hash encoding");
}
-
return update;
}
int deleted = 0;
if (o->encoding == REDIS_ENCODING_ZIPLIST) {
- unsigned char *zl, *fptr, *vptr;
+ unsigned char *zl, *fptr;
field = getDecodedObject(field);
zl = o->ptr;
fptr = ziplistIndex(zl, ZIPLIST_HEAD);
- while (fptr != NULL) {
- /* Compare field in ziplist with specified field */
- if (ziplistCompare(fptr, field->ptr, sdslen(field->ptr))) {
+ if (fptr != NULL) {
+ fptr = ziplistFind(fptr, field->ptr, sdslen(field->ptr), 1);
+ if (fptr != NULL) {
zl = ziplistDelete(zl,&fptr);
zl = ziplistDelete(zl,&fptr);
o->ptr = zl;
deleted = 1;
- break;
}
-
- /* Grab pointer to the value (fptr points to the field) */
- vptr = ziplistNext(zl, fptr);
- redisAssert(vptr != NULL);
-
- /* Grab pointer (if any) to the next field */
- fptr = ziplistNext(zl, vptr);
}
decrRefCount(field);
redisAssert(vptr != NULL);
fptr = ziplistNext(zl, vptr);
}
-
- if (fptr == NULL) {
- return REDIS_ERR;
- }
+ if (fptr == NULL) return REDIS_ERR;
/* Grab pointer to the value (fptr points to the field) */
vptr = ziplistNext(zl, fptr);
/* fptr, vptr now point to the first or next pair */
hi->fptr = fptr;
hi->vptr = vptr;
-
} else if (hi->encoding == REDIS_ENCODING_HT) {
- if ((hi->de = dictNext(hi->di)) == NULL) {
- return REDIS_ERR;
- }
-
+ if ((hi->de = dictNext(hi->di)) == NULL) return REDIS_ERR;
} else {
redisPanic("Unknown hash encoding");
}
-
return REDIS_OK;
}
value = hashTypeCurrentObject(hi, REDIS_HASH_VALUE);
value = tryObjectEncoding(value);
ret = dictAdd(dict, field, value);
- redisAssert(ret == DICT_OK);
+ if (ret != DICT_OK) {
+ redisLogHexDump(REDIS_WARNING,"ziplist with dup elements dump",
+ o->ptr,ziplistBlobLen(o->ptr));
+ redisAssert(ret == DICT_OK);
+ }
}
hashTypeReleaseIterator(hi);
}
void hincrbyCommand(redisClient *c) {
- long long value, incr;
+ long long value, incr, oldvalue;
robj *o, *current, *new;
if (getLongLongFromObjectOrReply(c,c->argv[3],&incr,NULL) != REDIS_OK) return;
value = 0;
}
+ oldvalue = value;
+ if ((incr < 0 && oldvalue < 0 && incr < (LLONG_MIN-oldvalue)) ||
+ (incr > 0 && oldvalue > 0 && incr > (LLONG_MAX-oldvalue))) {
+ addReplyError(c,"increment or decrement would overflow");
+ return;
+ }
value += incr;
new = createStringObjectFromLongLong(value);
hashTypeTryObjectEncoding(o,&c->argv[2],NULL);
void hincrbyfloatCommand(redisClient *c) {
double long value, incr;
- robj *o, *current, *new;
+ robj *o, *current, *new, *aux;
if (getLongDoubleFromObjectOrReply(c,c->argv[3],&incr,NULL) != REDIS_OK) return;
if ((o = hashTypeLookupWriteOrCreate(c,c->argv[1])) == NULL) return;
hashTypeTryObjectEncoding(o,&c->argv[2],NULL);
hashTypeSet(o,c->argv[2],new);
addReplyBulk(c,new);
- decrRefCount(new);
signalModifiedKey(c->db,c->argv[1]);
server.dirty++;
+
+ /* Always replicate HINCRBYFLOAT as an HSET command with the final value
+ * in order to make sure that differences in float pricision or formatting
+ * will not create differences in replicas or after an AOF restart. */
+ aux = createStringObject("HSET",4);
+ rewriteClientCommandArgument(c,0,aux);
+ decrRefCount(aux);
+ rewriteClientCommandArgument(c,3,new);
+ decrRefCount(new);
}
static void addHashFieldToReply(redisClient *c, robj *o, robj *field) {
projects / redis.git / blobdiff