Question

Given a table like this, where x and y have a unique constraint.

id,x,y
1, 1,1
2, 1,2
3, 2,3
4, 3,5
..

I want to increase the value x and y in a set of rows by a fixed amount with the UPDATE statement. Suppose I’m increasing them both by 1, it seems UPDATE follows id order and gives me an error after updating the row with 1 2, since it collides with the next row, 2 3, which hasn’t been updated to 3, 4 yet.

Googling around, I can’t find a way to force UPDATE to use an order. To do it in reverse would be enough for my application. I am also sure the set is consistent after the whole update.

Any solutions? Some way to force an order into the update, or any way to make it postpone the constraint check until it’s finished?

This is meant for a Django application, and it’s meant to be compatible with all supported databases. I know some databases have atomic transactions and this problem won’t happen, some have features to avoid this problem, but I need a strictly standard SQL solution.

Answer 1

For PostgreSQL you can define the primary key constraint as “deferrable” and then it would be only evaluated at commit time.

In PostgreSQL this would look like this:

postgres=>create table foo (
postgres(>    id integer not null,
postgres(>     x integer,
postgres(>     y integer
postgres(>);
CREATE TABLE
postgres=>alter table foo add constraint pk_foo primary key (id) deferrable initially deferred;
ALTER TABLE
postgres=> insert into foo (id, x,y) values (1,1,1), (2,1,1), (3,1,1);
INSERT 0 3
postgres=> commit;
COMMIT
postgres=> update foo set id = id + 1;
UPDATE 3
postgres=> commit;
COMMIT
postgres=> select * from foo;
 id | x | y
----+---+---
  2 | 1 | 1
  3 | 1 | 1
  4 | 1 | 1
(3 rows)
postgres=>

For Oracle this is not necessary as it will evaluate the UPDATE statement as a single atomic operation, so that works out of the box there.