django count specific rows in queryset

Question

class Order(models.Model):
   name = models.CharField(max_length=100)
   # other fields..
   user = models.ForeginKey(User)
   old = models.BooleanField(default=False)

I want to display all the orders of a specific user, but I want to split them those which are "old" and the ones who are not.

So, currently I do in views.py:

orders = Order.objects.filter(user=user)

In template:

First table:

<table>
{% for order in orders %}
{% if not order.old %}
   <tr>
     <td>... </td> 
   </tr>
{% endif %}
{% endfor %}
</table>

And another table:

{% for order in orders %}
{% if order.old %}
   <tr>
     <td>...</td>
   <tr>
{% endif %}
{% endfor %}

This way have some drawbacks, first, now I want to count how many of the orders are "old", to display this number in the template. I can't, unless I do another query. Is it possible to annotate(number_of_old=Count('old'))? Or I have to do another query?

So what would be the best?
1. Do two queries, one with old=False, another with old=True, and pass two querysets to the template. And use |len filter on the querysets
2. Do one query like this and split them somehow in python? That will be less convenient as I have a similar structures which I want to split like that.

And should I call the DB .count() at all?

EDIT:
If I would write my model like this:

class Order(models.Model):
   name = models.CharField(max_length=100)
   # other fields..
   user = models.ForeginKey(User)
   old = models.BooleanField(default=False)
   objects = CustomManager() # Custom manager


class CustomQueryset(models.QuerySet):
    def no_old(self):
        return self.filter(old=False)

class CustomManager(models.Manager):
    def get_queryset(self):
        return CustomQuerySet(model=self.model, using=self._db)

Is this template code produce one or two queries ?

{% if orders.no_old %}
{% for order orders.no_old %}
... 
{% endfor %}
{% endif %} 

Answer 1

You can't do any annotations, and there is no need to make .count() since you already have all the data in memory. So its really just between:

orders = Order.objects.filter(user=user)
old_orders = [o for o in orders if o.old]
new_orders = [o for o in orders if not o.old]

#or

old_orders = Order.objects.filter(user=user, old=True)
new_orders = Order.objects.filter(user=user, old=False)

In this specific scenario, I don't think there will be any performance difference. Personally I will choose the 2nd approach with the two queries.

A good read with tips about the problem: Django Database access optimization

Update

About the custom Manager which you introduce. I don't think you are doing it correctly I think what you want is this:

class CustomQueryset(models.QuerySet):
    def no_old(self):
        return self.filter(old=False)

class Order(models.Model):
   name = models.CharField(max_length=100)
   # other fields..
   user = models.ForeginKey(User)
   old = models.BooleanField(default=False)

   #if you already have a manager
   #objects = CustomManager.from_queryset(CustomQueryset)()
   #if you dont:
   objects = CustomQueryset.as_manager()

So having:

orders = Order.objects.filter(user=user)

If you do {% if orders.no_old %} will do another query, because this is new QuerySet instance which has no cache..

About the {% regroup %} tag

As you mention, in order to use it, you need to .order_by('old'), and if you have another order, you can still use it, just apply your order after the old, e.g. .order_by('old', 'another_field'). This way you will use only one Query and this will save you one iteration over the list (because Django will split the list iterating it only once), but you will get less readability in the template.