views:

726

answers:

4

I have a table with an IntegerField (hit_count), and when a page is visited (ie. http://site/page/3) I want record id 3 'hit_count' column in the database to increment by 1.

The query should be like: update table set hit_count = hit_count + 1 where id=3

Can I do this with the standard Django Model conventions? Or should I just write the query by hand?

I'm starting a new project, so I am trying to avoid hacks. We'll see how long this lasts!

Thanks!

A: 

The model conventions won't be atomic; write it by hand:

BEGIN
SELECT * FROM table WHERE id=3 FOR UPDATE
UPDATE table SET hit_count=hit_count+1 WHERE id=3
COMMIT
Ignacio Vazquez-Abrams
Django's ORM has support for this query (in trunk, and soon v1.1) - you don't need to write it by hand.
Carl Meyer
A: 

I would start by looking at the documentation for middleware. Ignacio's comment about the lack of atomic transactions is true, but this is a problem with the entire Django framework. Unless you're concerned about having a 100% accurate counter I wouldn't worry about it.

How is this a "problem with the entire Django framework?" You can have atomic transaction per request with TransactionMiddleware, or get finer-grained control with the functions in django.db.transaction.
Carl Meyer
Sure you can have transactions, but they are not enabled by default. If you build a simple CRUD application using the built-in Django admin you're going to have race conditions. Even the tutorial in the Django documentation has these kinds of problems.
The way you've phrased it makes it sound like an unavoidable problem, which is of course misleading to someone that may not know as much about Django as you.
Jordan
+3  A: 

As gerdemb says, you should write it into a middleware to make it really reusable. Or (simpler) write a function decorator. In fact, there are adaptors to use a middleware as a decorator and viceversa.

But if you're worried about performance and want to keep the DB queries per page hit low, you can use memcached's atomic increment operation. of course, in this case, you have to take care of persistence yourself.

Javier
For good performance, the memcached solution is best by far, but it is more complicated.
Carl Meyer
+8  A: 

If you use Django 1.1+, just use F expressions:

from django.db.models import F
...
MyModel.objects.filter(id=...).update(hit_count=F(hit_count)+1)

This will perform a single atomic database query.

As gerdemb says, you should consider putting this in a middleware to make it easily reusable so it doesn't clutter up all your views.

Carl Meyer
+1: http://docs.djangoproject.com/en/dev/topics/db/queries/#filters-can-reference-fields-on-the-model
S.Lott
Thanks - meant to link to that but forgot. I'll add it.
Carl Meyer
What I think you want is `MyModel.objects.get(id=...)` as opposed to `filter`; if we know it's a single row, why not make it clear?
Jared Forsyth
@Jared Because .get() is not lazy (it actually queries the database). Which is why individual model objects don't have a .update() method; once you've already queried, you just use .save(). But then you lose atomicity, which is the whole point here. The .update() method for atomic updates is only available on QuerySets, and is only possible because they are lazy.
Carl Meyer
Oh, that's interesting. Thanks.
Jared Forsyth