HMSETCK: set values in hash if another checks out

tsee · tsee · commit 9fdc57ca481b · 2014-04-28T09:11:23.000+02:00
hmsetck key checkfield checkvalue field1 value1 ...

Semantics are basically (pseudocode):

  if (hash-&gt;{checkfield} equals checkvalue) {
    foreach field in fields list {
      hash-&gt;{fieldX} = valueX
  }

within a hash-value.

This command is a very powerful primitive for Redis use cases that
require versioning of data. It's also much easier to use (since it's a
single command) to avoid races in such use cases than Redis transactions.

If you have strong latency and throughput requirements: Both Redis
transactions and Lua scripts are much more heavy-handed than this
single, fast, atomic command.

The particular use case I have is fast, race-free, versioned session
handling in a cross-datacenter setup, where each session is a hash with
am embedded version. If session updates only required one round-trip
(like with this command) and didn't require running a Lua script, that'd
be a improvement for us.
diff --git a/src/help.h b/src/help.h
@@ -269,6 +269,11 @@ struct commandHelp {
     "Set the value of a hash field, only if the field does not exist",
     5,
     "2.0.0" },
+    { "HMSETCK",
+    "key field-to-check value-to-check-for field value [field value ...]",
+    "Set values of a hash, only if another field has a particuler value",
+    5,
+    "2.9.11" },
     { "HVALS",
     "key",
     "Get all the values in a hash",
diff --git a/src/redis.c b/src/redis.c
@@ -185,6 +185,7 @@ struct redisCommand redisCommandTable[] = {
     {"zscan",zscanCommand,-3,"rR",0,NULL,1,1,1,0,0},
     {"hset",hsetCommand,4,"wm",0,NULL,1,1,1,0,0},
     {"hsetnx",hsetnxCommand,4,"wm",0,NULL,1,1,1,0,0},
+    {"hmsetck",hmsetckCommand,-6,"wm",0,NULL,1,1,1,0,0},
     {"hget",hgetCommand,3,"r",0,NULL,1,1,1,0,0},
     {"hmset",hmsetCommand,-4,"wm",0,NULL,1,1,1,0,0},
     {"hmget",hmgetCommand,-3,"r",0,NULL,1,1,1,0,0},
diff --git a/src/redis.h b/src/redis.h
@@ -1368,6 +1368,7 @@ void zrankCommand(redisClient *c);
 void zrevrankCommand(redisClient *c);
 void hsetCommand(redisClient *c);
 void hsetnxCommand(redisClient *c);
+void hmsetckCommand(redisClient *c);
 void hgetCommand(redisClient *c);
 void hmsetCommand(redisClient *c);
 void hmgetCommand(redisClient *c);
diff --git a/src/t_hash.c b/src/t_hash.c
@@ -492,6 +492,37 @@ void hsetnxCommand(redisClient *c) {
     }
 }
 
+/* HSETCK myhash checkkey checkval setkey setval */
+void hmsetckCommand(redisClient *c) {
+    robj *o;
+    robj *testobj;
+    int i;
+
+    if ((o = hashTypeLookupWriteOrCreate(c,c->argv[1])) == NULL) return;
+
+    if (!hashTypeExists(o, c->argv[2])) {
+        addReply(c, shared.czero);
+        return;
+    }
+
+    testobj = hashTypeGetObject(o,c->argv[2]);
+    if (!equalStringObjects(testobj, c->argv[3])) {
+        addReply(c, shared.czero);
+        decrRefCount(testobj);
+        return;
+    }
+
+    hashTypeTryConversion(o,c->argv,4,c->argc-1);
+    for (i = 4; i < c->argc; i += 2) {
+        hashTypeTryObjectEncoding(o,&c->argv[i], &c->argv[i+1]);
+        hashTypeSet(o,c->argv[i],c->argv[i+1]);
+    }
+    addReply(c, shared.ok);
+    signalModifiedKey(c->db,c->argv[1]);
+    notifyKeyspaceEvent(REDIS_NOTIFY_HASH,"hset",c->argv[1],c->db->id);
+    server.dirty++;
+}
+
 void hmsetCommand(redisClient *c) {
     int i;
     robj *o;
diff --git a/tests/unit/type/hash.tcl b/tests/unit/type/hash.tcl
@@ -107,6 +107,70 @@ start_server {tags {"hash"}} {
         set _ $result
     } {foo}
 
+    test {HMSETCK check-key missing - small hash} {
+        r hmsetck newhash __123123123__ version1 foo bar
+        set result [r hget newhash foo]
+        set _ $result
+    } {}
+
+    test {HMSETCK check-key exists but no match - small hash} {
+        r hset newhash __123123123__ version2
+        r hmsetck newhash __123123123__ version1 foo bar
+        set result [r hget newhash foo]
+        set _ $result
+    } {}
+
+    test {HMSETCK check-key exists and matches - small hash} {
+        r hset newhash __123123123__ version1
+        r hmsetck newhash __123123123__ version1 foo bar
+        set result [r hget newhash foo]
+        r hdel newhash foo
+        set _ $result
+    } {bar}
+
+    test {HMSETCK check-key exists and matches, multi - small hash} {
+        r hset newhash __123123123__ version1
+        r hmsetck newhash __123123123__ version1 __123123123__ version2 foo bar
+        set rv {}
+        lappend rv [r hget newhash __123123123__]
+        lappend rv [r hget newhash foo]
+        r hdel newhash foo
+        set _ $rv
+    } {version2 bar}
+
+    test {HMSETCK check-key missing - big hash} {
+        for {set i 0} {$i < 1050} {incr i} {
+            set key [randstring 0 8 alpha]
+            set val [randstring 0 8 alpha]
+            r hset hmsetckbighash $key $val
+        }
+        r hmsetck hmsetckbighash __123123123__ version1 foo bar
+        r hget hmsetckbighash foo
+    } {}
+
+    test {HMSETCK check-key exists but no match - big hash} {
+        r hset hmsetckbighash __123123123__ version2
+        r hmsetck hmsetckbighash __123123123__ version1 foo bar
+        r hget hmsetckbighash foo
+    } {}
+
+    test {HMSETCK check-key exists and matches - big hash} {
+        r hset hmsetckbighash __123123123__ version1
+        r hmsetck hmsetckbighash __123123123__ version1 foo bar
+        set result [r hget hmsetckbighash foo]
+        set _ $result
+    } {bar}
+
+    test {HMSETCK check-key exists and matches, multi - big hash} {
+        r hset hmsetckbighash __123123123__ version1
+        r hdel hmsetckbighash foo
+        r hmsetck hmsetckbighash __123123123__ version1 __123123123__ version2 foo bar
+        set rv {}
+        lappend rv [r hget hmsetckbighash __123123123__]
+        lappend rv [r hget hmsetckbighash foo]
+        set _ $rv
+    } {version2 bar}
+
     test {HMSET wrong number of args} {
         catch {r hmset smallhash key1 val1 key2} err
         format $err
