如何注释 Django QuerySet 聚合注释子查询

Question

I have a few Django models with a FK relationship between them:

from django.db import models


class Order(models.Model):
    notes = models.TextField(blank=True, null=True)


class OrderLine(models.Model):
    order = models.ForeignKey(Order, on_delete=models.CASCADE)
    quantity = models.PositiveIntegerField()
    price = models.DecimalField(max_digits=8, blank=True, decimal_places=2)

Given an OrderLine you can calculate its total as quantity by price:

def get_order_line_total(order_line):
    return order_line.quantity * order_line.price

Given an Order you can calculate its total as the sum of its order lines totals:

def get_order_total(order):
    order_total = 0
    for orderline_for in order.orderline_set.all():
        order_total += (order_line_for.quantity * order_line_for.price)
    return order_total

I want to annotate that totals in querysets so I can filtrate them, sort them, etc.

For the OrderLine models I found it pretty straight forward:

from django.db.models import F, FloatField, Sum


annotated_orderline_set = OrderLine.objects.annotate(orderline_total=Sum(F('quantity') * F('price'), output_field=FloatField()))

Now I want to annotate the total in an Order.objects queryset. I guess I would need to use a Subquery but I can't make it work. My guess is (Not working):

from django.db.models import F, FloatField, OuterRef, Subquery, Sum


Order.objects.annotate(
    order_total=Subquery(
        OrderLine.objects.filter(
            order=OuterRef('pk')
        ).annotate(
            orderline_total=Sum(F('quantity') * F('price'), output_field=FloatField())
        ).values(
            'orderline_total'
        ).aggregate(
            Sum('orderline_total')
        )['orderline_total__sum']
    )
)

# Not working, returns:
# ValueError: This queryset contains a reference to an outer query and may only be used in a subquery.

How could I solve this?

Answer 1

As @aedry comment pointed out, a very simple solution avoiding the Subquery is:

Order.objects.annotate(total=models.Sum(F('orderline_set__quantity') * F('orderline_set__price'), output_field=models.DecimalField(max_digits=10, decimal_places=2)))

(I applied the output_field=DecimalField idea from @Todor answer for type consistency)

Answer 2

You cannot use .aggregate because this evaluates the queryset immediately while you need this evaluation to be delayed until the outer query is being evaluated.

So the correct approach is to .annotate instead of .aggregate .

class OrderQuerySet(models.QuerySet):
    def annotate_total(self):
        return self.annotate(
            total=models.Subquery(
                OrderLine.objects.filter(
                    order=models.OuterRef('pk')
                ).annotate_total()
                .values('order')
                .annotate(total_sum=models.Sum('total'))
                .values('total_sum')
            )
        )


class Order(models.Model):
    # ...
    objects = OrderQuerySet.as_manager()


class OrderLineQuerySet(models.QuerySet):
    def annotate_total(self):
        return self.annotate(
            total=models.ExpressionWrapper(
                models.F('quantity')*models.F('price'),
                output_field=models.DecimalField(max_digits=10, decimal_places=2)
            )
        )


class OrderLine(models.Model):
    #...
    objects = OrderLineQuerySet.as_manager()


# Usage:
>>> for l in OrderLine.objects.all().annotate_total():
...    print(l.id, l.order_id, l.quantity, l.price, l.total)
... 
1 1 3 20.00 60
2 1 9 10.00 90
3 2 18 2.00 36

>>> for o in Order.objects.all().annotate_total():
...    print(o.id, o.total)
... 
1 150
2 36