I had an idea tonight while helping someone in #django. It revolved around using a postgres trigger to prevent overwrites with stale data.
Consider the following model:
class Person(models.Model): first_name = models.TextField() last_name = models.TextField()
If we had two users attempting to update a given instance at around the same time, Django would fetch whatever it had in the database when they did the GET request to fetch the form, and display that to them. It would also use whatever they sent back to save the object. In that case, the last update wins. Sometimes, this is what is required, but it does mean that one user’s changes would be completely overwritten, even if they had only changed something that the subsequent user did not change.
There are a couple of solutions to this problem. One is to use something like django-model-utils FieldTracker to record which fields have been changed, and only write those back using
instance.save(update_fields=...). If you are using a django Form (and you probably should be), then you can also inspect
form.changed_data to see what fields have changed.
However, that may not always be the best behaviour. Another solution would be to refuse to save something that had changed since they initially fetched the object, and instead show them the changes, allow them to update to whatever it should be now, and then resubmit. After which time, someone else may have made changes, but then the process repeats.
But how can we know that the object has changed?
One solution could be to use a trigger (and an extra column).
class Person(models.Model): first_name = models.TextField() last_name = models.TextField() _last_state = models.UUIDField()
And in our database trigger:
CREATE EXTENSION "uuid-ossp"; CREATE OR REPLACE FUNCTION prevent_clobbering() RETURNS TRIGGER AS $prevent_clobbering$ BEGIN IF NEW._last_state != OLD._last_state THEN RAISE EXCEPTION 'Object was changed'; END IF; NEW._last_state = uuid_generate_v4(); RETURN NEW; END; $prevent_clobbering$ LANGUAGE plpgsql STRICT IMMUTABLE; CREATE TRIGGER prevent_clobbering BEFORE UPDATE ON person_person FOR EACH ROW EXECUTE PROCEDURE prevent_clobbering();
You’d also want to have some level of handling in Django to capture the exception, and re-display the form. You can’t use the form/model validation handling for this, as it needs to happen during the save.
To make this work would also require the _last_state column to have a
DEFAULT uuid_generate_v4(), so that newly created rows would get a value.
This is only a prototype at this stage, but does work as a mechanism for preventing overwrites. As usual, there’s probably more work in the application server, and indeed in the UI that would need to be required for displaying stale/updated values.
What this does have going for it is that it’s happening at the database level. There is no way that an update could happen (unless the request coming in happened to guess what the new UUID was going to be).
What about drawbacks? Well, there is a bit more storage in the UUID, and we need to regenerate a new one each time we save a row. We could have something that checks the other rows looking for changes.
Perhaps we could even have the hash of the previous row’s value stored in this field - that way it would not matter that there had been N changes, what matters is the value the user saw before they entered their changes.
Another drawback is that it’s hard-coded to a specific column. We could rewrite the function to allow defining the column when we create the trigger:
CREATE TRIGGER prevent_clobbering BEFORE UPDATE ON person_person FOR EACH ROW EXECUTE PROCEDURE prevent_clobbering('_last_state_');
But that requires a bit more work in the function itself:
CREATE OR REPLACE FUNCTION prevent_clobbering() RETURNS TRIGGER AS $prevent_clobbering$ BEGIN IF to_jsonb(NEW)->TG_ARGV != to_jsonb(OLD)->TG_ARGV THEN RAISE EXCEPTION 'Object was changed'; END IF; NEW._last_state = uuid_generate_v4(); RETURN NEW; END; $prevent_clobbering$ LANGUAGE plpgsql STRICT IMMUTABLE;