Key-based cache expiration - caching

Question

I'd like to discuss post on 37signals blog named How key-based cache expiration works. I'm Django developer, not RoR, so here is Django "translation" by Ross Poulton: Key-based cache expiration with Django.
As you can see, main idea is following: we have "russian-doll" structure, where one object contains several levels of other.
class A:
timestamp updated_at;
class B:
A parent;
timestamp updated_at;
class C:
B parent;
timestamp updated_at;
View (for example, HTML) of object of class A is cached with all related objects. When class C is updated, we need:
Update timestamp in C.
Update timestamp in B.
Update timestamp in A.
When we access view of class A after this, we need:
Make SELECT to get timestamp from A.
Check, that there is no cached object with this timestamp, so we
need to recache it.
Make SELECT to get A data.
Make SELECT to get all timestamps from B.
Get Bs exist in cache.
Make SELECT to get Bs that not exists in cache.
Make SELECT to get all timestamps of Cs related with Bs that not
exist in cache.
Get Cs from cache, if exist.
Make SELECT to get Cs that not exist in cache.
So, if I understand this strategy right, we need to do 6 queries to DB - 2 for each object: one will get timestamps, second - objects, outdated in cache.
Instead, if we will reset all data, we need to make only 3 queries:
Get object A.
Get related objects B.
Get related objects C.
As I know, it's ofter better to execute 3 queries with more data instead of 6 queries with less. So is this strategy effective?
Of course, we can store timestamps in cache too, but in this case we will face with problem of invalidation of timestamp. So it's no sense to invalidate data for strategy that needed to avoid invalidation.
Please, correct me if I wrong in understanding of scope or principle of work of this algorithm.