# book 总数.

>>> Book.objects.count()

2452

# publisher=BaloneyPress的book总数.

>>> Book.objects.filter(publisher__name='BaloneyPress').count()

73

# 所有book的平均价格.

>>> from django.db.models import Avg

>>> Book.objects.all().aggregate(Avg('price'))

{'price__avg': 34.35}

# 所有book的最高价格

>>> from django.db.models import Max

>>> Book.objects.all().aggregate(Max('price'))

{'price__max': Decimal('81.20')}

# 每页均价

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

>>> Book.objects.all().aggregate(

...    price_per_page=Sum(F('price')/F('pages'), output_field=FloatField()))

{'price_per_page': 0.4470664529184653}

# 下面的所有查询都涉及到遍历 Book<->Publisher

# foreign key relationship backwards.

# Each publisher, each with a count of books as a "num_books" attribute.

>>> from django.db.models import Count

>>> pubs = Publisher.objects.annotate(num_books=Count('book'))

>>> pubs

<QuerySet [<Publisher: BaloneyPress>, <Publisher: SalamiPress>, ...]>

>>> pubs[0].num_books

73

# The top 5 publishers, in order by number of books.

>>> pubs = Publisher.objects.annotate(num_books=Count('book')).order_by('-num_books')[:5]

>>> pubs[0].num_books

1323

>>> Book.objects.all()

>>> from django.db.models import Avg

>>> Book.objects.all().aggregate(Avg('price'))

{'price__avg': 34.35}

>>> Book.objects.aggregate(Avg('price'))

{'price__avg': 34.35}

>>> Book.objects.aggregate(average_price=Avg('price'))

{'average_price': 34.35}

>>> from django.db.models import Avg, Max, Min

>>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))

{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}

# Build an annotated queryset

>>> from django.db.models import Count

>>> q = Book.objects.annotate(Count('authors'))

# 查询queryset中的第一个对象

>>> q[0]

<Book: The Definitive Guide to Django>

>>> q[0].authors__count

2

# 查询queryset中的第二个对象

>>> q[1]

<Book: Practical Django Projects>

>>> q[1].authors__count

1

>>> q = Book.objects.annotate(num_authors=Count('authors'))

>>> q[0].num_authors

2

>>> q[1].num_authors

1

如果不明白，可以查看SQL query!

如果想知道查询具体做了什么，请查看 QuerySet 的 query 属性。

>>> from django.db.models import Max, Min

>>> Store.objects.annotate(min_price=Min('books__price'), max_price=Max('books__price'))

>>> Store.objects.aggregate(min_price=Min('books__price'), max_price=Max('books__price'))

>>> Store.objects.aggregate(youngest_age=Min('books__authors__age'))

对注解过滤

注解的值也可以被过滤。 而注解的别名也可以和模型字段一样，在 filter() 和 exclude() 子句中使用。

例如，要得到不止一个作者的图书，可以用:

>>> Book.objects.annotate(num_authors=Count('authors')).filter(num_authors__gt=1)

这个查询首先计算注解结果，然后再生成一个作用于注解上的过滤器。

annotate() 和 filter() 的顺序

在写一个包含 annotate() 和 filter() 的复杂查询时，要特别注意作用于 QuerySet 子句的顺序。

使用 annotate() 子句作用于某个查询时,要根据查询的状态才能得出注解值，而状态由annotate()``的位置决定，所以 ``filter() 和 annotate() 不能随意交换位置。

比如，有以下数据:

• Publisher A 有两本 book，ratings 分别为4和5.
• Publisher B 有两本 book，ratings 分别为1和4.
• Publisher C 有一本 book，rating 为1.

以 Count 聚合为例:

>>> a, b = Publisher.objects.annotate(num_books=Count('book', distinct=True)).filter(book__rating__gt=3.0)

>>> a, a.num_books

(<Publisher: A>, 2)

>>> b, b.num_books

(<Publisher: B>, 2)

>>> a, b = Publisher.objects.filter(book__rating__gt=3.0).annotate(num_books=Count('book'))

>>> a, a.num_books

(<Publisher: A>, 2)

>>> b, b.num_books

(<Publisher: B>, 1)

两个查询都返回至少有一本书的rating大于3的publisher列表，因此publisher C不在列表中。

在第一个查询中, 注解先于过滤, 因此过滤不会影响注解。设置 distinct=True 避免 query bug 。

第二个查询先计算每个publisher中rating的值超过3.0的图书。筛选器先于注释，因此筛选器在计算注释时已经约束了对象。

下面是另一个是 Avg 聚合的例子:

>>> a, b = Publisher.objects.annotate(avg_rating=Avg('book__rating')).filter(book__rating__gt=3.0)

>>> a, a.avg_rating

(<Publisher: A>, 4.5)  # (5+4)/2

>>> b, b.avg_rating

(<Publisher: B>, 2.5)  # (1+4)/2

>>> a, b = Publisher.objects.filter(book__rating__gt=3.0).annotate(avg_rating=Avg('book__rating'))

>>> a, a.avg_rating

(<Publisher: A>, 4.5)  # (5+4)/2

>>> b, b.avg_rating

(<Publisher: B>, 4.0)  # 4/1 (book with rating 1 excluded)

第一个查询是计算至少有一本书的rating超过3.0的publisher的所有图书的平均rating， 第二个查询要计算publisher的rating超过3.0的书的平均rating。

这种情况，很难直观地了解ORM如何将复杂的queryset翻译成SQL查询， 因此在不清楚时，可以使用 str(queryset.query) 来检查SQL，并且多一点测试。

annotate() 和 values() 的顺序

和使用 filter() 一样, 作用于某个查询的 annotate() 和 values() 子句的顺序非常重要。如果values() 子句在 annotate() 之前, 就会根据 values() 子句产生的分组来计算注解。

但是，如果 annotate() 子句在 values() 之前, 就会根据整个查询集生成注解。这种情况下，values() 子句只能限制输出的字段。

举个例子，如果互换了上个例子中 values() 和 annotate() 子句的顺序:

>>> Author.objects.annotate(average_rating=Avg('book__rating')).values('name', 'average_rating')

这段代码将给每个作者添加一个唯一的字段，但只有作者名称和 average_rating 注解会返回在输出结果中。

这里 average_rating 显式地包含在返回的列表当中。这也正是因为

values() 和 annotate() 子句的顺序问题。

如果 values() 子句在 annotate() 之前, 注解会被自动添加到结果集中。 但是，如果 values() 子句作用于 annotate() 之后, 您需要在 values 中显式地包含聚合列。

默认排序和 order_by()

查询集中的 order_by() 部分(或是模型中默认定义的排序项) 会在选择输出数据时被用到。 即使这些字段没有在 values() 中指定也会被用到。 这些字段用来组合“相似”结果，它们可以使相似的结果行看起来是独立的。尤其是在计数的时候。

通过例子中的方法，假设有一个这样的模型:

from django.db import models

class Item(models.Model):

    name = models.CharField(max_length=10)

    data = models.IntegerField()

    class Meta:

        ordering = ["name"]

关键的部分就是在模型默认排序项中设置的 name 字段。 如果你想知道每个非重复的 data 值出现的次数。可以这样写:

# Warning: not quite correct!

Item.objects.values("data").annotate(Count("id"))

...这部分代码的用意是想通过它们相同的 data 值来分组 Item 对象。然后在每个分组中计算 id总数。但是上面那样做是行不通的，这是因为默认排序项中的 name 也是一个分组项。 所以这个查询会根据非重复的 (data, name) 进行分组。想要得到正确的结果应该这样写:

Item.objects.values("data").annotate(Count("id")).order_by()

...这样就清空了查询中的所有排序项。你也可以在 order_by() 中使用“data”。这样结果还是一样的。

这个行为与查询集文档中提到的 distinct() 一样， 而且生成规则也一样： 通常情况下，如果希望在结果中有额外的列，就可以清除排序，或者确保它只有在 values() 中调用的字段。