WATCH accounts for modifications by its own connection

[ProgerXP]

Documentation about Redis transactions (http://redis.io/topics/transactions) says this:

Optimistic locking using check-and-set

WATCHed keys are monitored in order to detect changes against them. If at least one watched key is modified before the EXEC command, the whole transaction aborts [...]

The above suggests that it doesn't matter who changes the watched key(s) - the same client (that has watched them) or another client.

But the docs have also this fragment:

WATCH explained

[...] we are asking Redis to perform the transaction only if no other client modified any of the WATCHed keys [...]

This explicitly says that WATCH will ignore changes by the same client but doesn't say who is that other client.

I have tried this (single session - single "client"?):

127.0.0.1:6379> watch o
OK
127.0.0.1:6379> set o 1
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> get o
QUEUED
127.0.0.1:6379> exec
(nil)

is this a bug in WATCH or the documentation is misleading? Should we remove this "only if no other client" reference from the docs?

[badboy]

At this point I'd say misleading documentation, as the behaviour probably was always that every key modification counts.
cc @antirez

[ProgerXP]

After some research I see why the docs mention "other clients":

• If the same client does watch-set-multi-exec then it fails (as in my first post)
• If the same client does watch-multi-set-exec - it succeeds
• If client A does watch, client B does set, client A does multi-exec then it fails
• If client A does watch, client B does multi-set-exec, client A does multi-exec - it also fails (compare with case 2)

In other words, the docs should say that EXEC will fail in all cases when the key is modified unless it was done by the same client inside the watched multi/exec block.

This might be expected behaviour but why changes before MULTI are treated like a change by another client? I'd say they should be ignored likewise.

[ProgerXP]

To summarize my previous post, I'm testing php-redis extension (https://github.com/phpredis/phpredis):

  function testWatchChangeBySelfBeforeMulti() {
    $redis = new Redis;
    $redis->connect('127.0.0.1');
    $redis->delete('o');
    $redis->watch('o');
    $redis->set('o', 1);
    $redis->multi();
    $redis->get('o');
    // This fails.
    $this->assertTrue(is_array( $redis->exec() ));
  }

  function testWatchChangeBySelfAfterMulti() {
    $redis = new Redis;
    $redis->connect('127.0.0.1');
    $redis->delete('o');
    $redis->watch('o');
    $redis->multi();
    $redis->set('o', 1);
    $redis->get('o');
    $this->assertTrue(is_array( $redis->exec() ));
  }

  function testWatchChangeByOtherBeforeMulti() {
    $redis = new Redis;
    $redis->connect('127.0.0.1');

    $redis2 = new Redis;
    $redis2->connect('127.0.0.1');

    $redis->delete('o');
    $redis->watch('o');
    $redis2->set('o', 1);
    $redis->multi();
    $redis->get('o');
    $this->assertFalse($redis->exec());
  }

  function testWatchChangeByOtherAfterMulti() {
    $redis = new Redis;
    $redis->connect('127.0.0.1');

    $redis2 = new Redis;
    $redis2->connect('127.0.0.1');

    $redis->delete('o');
    $redis->watch('o');
    $redis->multi();
    $redis2->set('o', 1);
    $redis->get('o');
    $this->assertFalse($redis->exec());
  }

[badboy]

MULTI/EXEC introduce a transaction. Commands are only executed on EXEC.
Everything before MULTI is executed right away.
WATCH is explicitely used to mark keys used in a transaction. If you edit the key outside of the transaction it is clearly modified, no matter who modified it.
That's why I think the current behaviour is just fine and the documentation can be a bit more clear on this.

[ProgerXP]

If you edit the key outside of the transaction it is clearly modified, no matter who modified it.

Then just need to correct the docs. Send you a pull request?

[ProgerXP]

@badboy any reason why my pull request is untouched?

[badboy]

Puh, for some reason I failed to review it. I'm sorry for that. Will do it later today.