Djangoのデータベース抽象API のトピックガイドでは、個別のオブジェクトの作成、取得、削除を行うDjangoのクエリの使い方を説明しました。しかし、オブジェクトのコレクションを 集計 (アグリゲーション) した値や、集計することによって派生された値を取得しなければならないことがあります。 このトピックガイドはで、Django のクエリを使って集計値を生成して返す方法を説明します。
\nこのガイドでは、以下のモデルを使用します。これらのモデルは、一連のオンライン書店の在庫を追跡するために使用されます。
\nfrom django.db import models\n\nclass Author(models.Model):\n name = models.CharField(max_length=100)\n age = models.IntegerField()\n\nclass Publisher(models.Model):\n name = models.CharField(max_length=300)\n num_awards = models.IntegerField()\n\nclass Book(models.Model):\n name = models.CharField(max_length=300)\n pages = models.IntegerField()\n price = models.DecimalField(max_digits=10, decimal_places=2)\n rating = models.FloatField()\n authors = models.ManyToManyField(Author)\n publisher = models.ForeignKey(Publisher)\n pubdate = models.DateField()\n\nclass Store(models.Model):\n name = models.CharField(max_length=300)\n books = models.ManyToManyField(Book)\n registered_users = models.PositiveIntegerField()\nお急ぎですか？ 上のモデルを使った場合の一般的な集計クエリは以下のようになります:
\n# Total number of books.\n>>> Book.objects.count()\n2452\n\n# Total number of books with publisher=BaloneyPress\n>>> Book.objects.filter(publisher__name='BaloneyPress').count()\n73\n\n# Average price across all books.\n>>> from django.db.models import Avg\n>>> Book.objects.all().aggregate(Avg('price'))\n{'price__avg': 34.35}\n\n# Max price across all books.\n>>> from django.db.models import Max\n>>> Book.objects.all().aggregate(Max('price'))\n{'price__max': Decimal('81.20')}\n\n# Cost per page\n>>> from django.db.models import F, FloatField, Sum\n>>> Book.objects.all().aggregate(\n... price_per_page=Sum(F('price')/F('pages'), output_field=FloatField()))\n{'price_per_page': 0.4470664529184653}\n\n# All the following queries involve traversing the Book<->Publisher\n# foreign key relationship backwards.\n\n# Each publisher, each with a count of books as a "num_books" attribute.\n>>> from django.db.models import Count\n>>> pubs = Publisher.objects.annotate(num_books=Count('book'))\n>>> pubs\n<QuerySet [<Publisher: BaloneyPress>, <Publisher: SalamiPress>, ...]>\n>>> pubs[0].num_books\n73\n\n# The top 5 publishers, in order by number of books.\n>>> pubs = Publisher.objects.annotate(num_books=Count('book')).order_by('-num_books')[:5]\n>>> pubs[0].num_books\n1323\nQuerySet に対して集計を生成するLink to this heading#Django では集約を生成するために 2 つの方法が用意されています。1 つめは、 全 QuerySet に対して合計値を生成する方法です。例えば、販売中の全ての書籍の平均価格を計算したい場合などです。Django のクエリ文法では、全書籍セットを表現するための方法が用意されています:
>>> Book.objects.all()\n必要なのは、この QuerySet に含まれるオブジェクトに対して合計値を計算する方法です。QuerySet に aggregate() 句を加えることで計算されます:
>>> from django.db.models import Avg\n>>> Book.objects.all().aggregate(Avg('price'))\n{'price__avg': 34.35}\n例にある all() は冗長なので、よりシンプルにできます:
>>> Book.objects.aggregate(Avg('price'))\n{'price__avg': 34.35}\naggregate() 句への引数は計算したい集約値を表します - この例では、 Book モデルの price フィールドの平均になります。 利用可能な集約関数の一覧は QuerySet リファレンス にあります。
aggregate() は QuerySet の最後の句になります。それが呼び出されると、name-value のペアの辞書が返されます。name は集計値に対する識別子です; valueは 計算された集計値です。 name はフィールド名と集計関数より自動的に生成されます。 集約値の name を手動で指定したい場合は、集約句を指定する際に名前を指定します:
>>> Book.objects.aggregate(average_price=Avg('price'))\n{'average_price': 34.35}\n1 つ以上の集計を生成したい場合は、aggregate() 句に別の引数を追加します。よって、全書籍の最高の価格と最低の価格を知りたい場合は 、以下のクエリを発行します:
>>> from django.db.models import Avg, Max, Min\n>>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))\n{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}\nQuerySet の各アイテムに対する集計を生成するLink to this heading#サマリ値を生成する 2 つ目の方法は、 QuerySet 内の各オブジェクトに対して個別のサマリを生成することです。例えば、書籍の一覧を取得しようとする場合には、 それぞれの書籍に寄稿している著者が何名いるのかを知りたいこともあるでしょう。 各 Book は Author に対して many-to-many の関係を持っています; この QuerySet 内で、各書籍の関係性を集計できます。
オブジェクトごとのサマリは annotate() 句を使うことで生成することができ ます。 annotate() が指定されると、QuerySet の各オブジェクトは 指定された値で注釈付け (annotate) されます。
この注釈付け ( annotation ) 構文は aggregate() 句で使われる構文と全く同じです。annotate() への各引数は、計算される集計方法を記述します。 例えば、書籍を著者数で注釈付けするには:
# Build an annotated queryset\n>>> from django.db.models import Count\n>>> q = Book.objects.annotate(Count('authors'))\n# Interrogate the first object in the queryset\n>>> q[0]\n<Book: The Definitive Guide to Django>\n>>> q[0].authors__count\n2\n# Interrogate the second object in the queryset\n>>> q[1]\n<Book: Practical Django Projects>\n>>> q[1].authors__count\n1\naggregate() と同様に、注釈 (annotation) の名前は集計関数の名前と集計されるフィールドから自動的に作成されます。 注釈付けを指定する時にエイリアス名を指定すると、このデフォルトの名前をオーバーライドすることができます:
>>> q = Book.objects.annotate(num_authors=Count('authors'))\n>>> q[0].num_authors\n2\n>>> q[1].num_authors\n1\naggregate() とは違って、annotate() は最終句では ありません 。annotate() 句のアウトプットは QuerySet です; この QuerySet は、他の QuerySet の操作によって修正可能です。 filter()、order_by などに加えて、別の annotate() を追加呼び出しすることもできます。
annotate() と複数の集計 (アグリゲーション) を統合することは、 誤った結果を生み出します。サブクエリの代わりに結合が使われるからです:
>>> book = Book.objects.first()\n>>> book.authors.count()\n2\n>>> book.store_set.count()\n3\n>>> q = Book.objects.annotate(Count('authors'), Count('store'))\n>>> q[0].authors__count\n6\n>>> q[0].store__count\n6\nほとんどの集計方法では、この問題を逃れるすべはありませんが、Count では distinct が助けになります:
>>> q = Book.objects.annotate(Count('authors', distinct=True), Count('store', distinct=True))\n>>> q[0].authors__count\n2\n>>> q[0].store__count\n3\nこれまでのところ、クエリ問い合わせされたモデルに属したフィールドに対する集計だけを見てきました。しかし、集計したい値が、クエリ問い合わせをしているモデルに関係しているモデルに属している場合もあります。
\n集計関数の中で、集計するフィールドを特定するとき、Django はフィルター内で関係するフィールドを参照するためにも使われる double underscore notation を使えるようにしています。Django は関連する値を取得し集計するために必要なテーブル結合を処理します。
\n例えば、各店舗で販売されている書籍の価格帯を調べるために、以下のアノテーションを使うことができます:
\n>>> from django.db.models import Max, Min\n>>> Store.objects.annotate(min_price=Min('books__price'), max_price=Max('books__price'))\nこれは、Store モデルを取得し、(many-to-many リレーションシップを通じて) Book モデルと結合し、そして書籍モデルの price フィールドの最大値と最小値を計算するように、Django に通知します。
同じルールが aggregate() 句にも適用されます。全店舗で販売中の全書籍の中での最低価格と最高価格を知りたい場合は、以下の集計方法を使うことができます:
>>> Store.objects.aggregate(min_price=Min('books__price'), max_price=Max('books__price'))\n結合チェーンは、必要なだけ深くできます。たとえば、販売可能な書籍のうち最年少の著者の年齢を抽出するには、次のクエリを発行できます:
\n>>> Store.objects.aggregate(youngest_age=Min('books__authors__age'))\nIn a way similar to Lookups that span relationships, aggregations and\nannotations on fields of models or models that are related to the one you are\nquerying can include traversing "reverse" relationships. The lowercase name\nof related models and double-underscores are used here too.
\nFor example, we can ask for all publishers, annotated with their respective\ntotal book stock counters (note how we use 'book' to specify the\nPublisher -> Book reverse foreign key hop):
>>> from django.db.models import Count, Min, Sum, Avg\n>>> Publisher.objects.annotate(Count('book'))\n(Every Publisher in the resulting QuerySet will have an extra attribute\ncalled book__count.)
We can also ask for the oldest book of any of those managed by every publisher:
\n>>> Publisher.objects.aggregate(oldest_pubdate=Min('book__pubdate'))\n(The resulting dictionary will have a key called 'oldest_pubdate'. If no\nsuch alias were specified, it would be the rather long 'book__pubdate__min'.)
This doesn't apply just to foreign keys. It also works with many-to-many\nrelations. For example, we can ask for every author, annotated with the total\nnumber of pages considering all the books the author has (co-)authored (note how we\nuse 'book' to specify the Author -> Book reverse many-to-many hop):
>>> Author.objects.annotate(total_pages=Sum('book__pages'))\n(Every Author in the resulting QuerySet will have an extra attribute\ncalled total_pages. If no such alias were specified, it would be the rather\nlong book__pages__sum.)
Or ask for the average rating of all the books written by author(s) we have on\nfile:
\n>>> Author.objects.aggregate(average_rating=Avg('book__rating'))\n(The resulting dictionary will have a key called 'average_rating'. If no\nsuch alias were specified, it would be the rather long 'book__rating__avg'.)
QuerySet clausesLink to this heading#filter() and exclude()Link to this heading#Aggregates can also participate in filters. Any filter() (or\nexclude()) applied to normal model fields will have the effect of\nconstraining the objects that are considered for aggregation.
When used with an annotate() clause, a filter has the effect of\nconstraining the objects for which an annotation is calculated. For example,\nyou can generate an annotated list of all books that have a title starting\nwith "Django" using the query:
>>> from django.db.models import Count, Avg\n>>> Book.objects.filter(name__startswith="Django").annotate(num_authors=Count('authors'))\nWhen used with an aggregate() clause, a filter has the effect of\nconstraining the objects over which the aggregate is calculated.\nFor example, you can generate the average price of all books with a\ntitle that starts with "Django" using the query:
>>> Book.objects.filter(name__startswith="Django").aggregate(Avg('price'))\nAnnotated values can also be filtered. The alias for the annotation can be\nused in filter() and exclude() clauses in the same way as any other\nmodel field.
For example, to generate a list of books that have more than one author,\nyou can issue the query:
\n>>> Book.objects.annotate(num_authors=Count('authors')).filter(num_authors__gt=1)\nThis query generates an annotated result set, and then generates a filter\nbased upon that annotation.
\nannotate() and filter() clausesLink to this heading#When developing a complex query that involves both annotate() and\nfilter() clauses, pay particular attention to the order in which the\nclauses are applied to the QuerySet.
When an annotate() clause is applied to a query, the annotation is computed\nover the state of the query up to the point where the annotation is requested.\nThe practical implication of this is that filter() and annotate() are\nnot commutative operations.
Given:
\nPublisher A has two books with ratings 4 and 5.
Publisher B has two books with ratings 1 and 4.
Publisher C has one book with rating 1.
Here's an example with the Count aggregate:
>>> a, b = Publisher.objects.annotate(num_books=Count('book', distinct=True)).filter(book__rating__gt=3.0)\n>>> a, a.num_books\n(<Publisher: A>, 2)\n>>> b, b.num_books\n(<Publisher: B>, 2)\n\n>>> a, b = Publisher.objects.filter(book__rating__gt=3.0).annotate(num_books=Count('book'))\n>>> a, a.num_books\n(<Publisher: A>, 2)\n>>> b, b.num_books\n(<Publisher: B>, 1)\nBoth queries return a list of publishers that have at least one book with a\nrating exceeding 3.0, hence publisher C is excluded.
\nIn the first query, the annotation precedes the filter, so the filter has no\neffect on the annotation. distinct=True is required to avoid a query\nbug.
The second query counts the number of books that have a rating exceeding 3.0\nfor each publisher. The filter precedes the annotation, so the filter\nconstrains the objects considered when calculating the annotation.
\nHere's another example with the Avg aggregate:
>>> a, b = Publisher.objects.annotate(avg_rating=Avg('book__rating')).filter(book__rating__gt=3.0)\n>>> a, a.avg_rating\n(<Publisher: A>, 4.5) # (5+4)/2\n>>> b, b.avg_rating\n(<Publisher: B>, 2.5) # (1+4)/2\n\n>>> a, b = Publisher.objects.filter(book__rating__gt=3.0).annotate(avg_rating=Avg('book__rating'))\n>>> a, a.avg_rating\n(<Publisher: A>, 4.5) # (5+4)/2\n>>> b, b.avg_rating\n(<Publisher: B>, 4.0) # 4/1 (book with rating 1 excluded)\nThe first query asks for the average rating of all a publisher's books for\npublisher's that have at least one book with a rating exceeding 3.0. The second\nquery asks for the average of a publisher's book's ratings for only those\nratings exceeding 3.0.
\nIt's difficult to intuit how the ORM will translate complex querysets into SQL\nqueries so when in doubt, inspect the SQL with str(queryset.query) and\nwrite plenty of tests.
order_by()Link to this heading#Annotations can be used as a basis for ordering. When you\ndefine an order_by() clause, the aggregates you provide can reference\nany alias defined as part of an annotate() clause in the query.
For example, to order a QuerySet of books by the number of authors\nthat have contributed to the book, you could use the following query:
>>> Book.objects.annotate(num_authors=Count('authors')).order_by('num_authors')\nvalues()Link to this heading#Ordinarily, annotations are generated on a per-object basis - an annotated\nQuerySet will return one result for each object in the original\nQuerySet. However, when a values() clause is used to constrain the\ncolumns that are returned in the result set, the method for evaluating\nannotations is slightly different. Instead of returning an annotated result\nfor each result in the original QuerySet, the original results are\ngrouped according to the unique combinations of the fields specified in the\nvalues() clause. An annotation is then provided for each unique group;\nthe annotation is computed over all members of the group.
For example, consider an author query that attempts to find out the average\nrating of books written by each author:
\n>>> Author.objects.annotate(average_rating=Avg('book__rating'))\nThis will return one result for each author in the database, annotated with\ntheir average book rating.
\nHowever, the result will be slightly different if you use a values() clause:
>>> Author.objects.values('name').annotate(average_rating=Avg('book__rating'))\nIn this example, the authors will be grouped by name, so you will only get\nan annotated result for each unique author name. This means if you have\ntwo authors with the same name, their results will be merged into a single\nresult in the output of the query; the average will be computed as the\naverage over the books written by both authors.
\nannotate() and values() clausesLink to this heading#As with the filter() clause, the order in which annotate() and\nvalues() clauses are applied to a query is significant. If the\nvalues() clause precedes the annotate(), the annotation will be\ncomputed using the grouping described by the values() clause.
However, if the annotate() clause precedes the values() clause,\nthe annotations will be generated over the entire query set. In this case,\nthe values() clause only constrains the fields that are generated on\noutput.
For example, if we reverse the order of the values() and annotate()\nclause from our previous example:
>>> Author.objects.annotate(average_rating=Avg('book__rating')).values('name', 'average_rating')\nThis will now yield one unique result for each author; however, only\nthe author's name and the average_rating annotation will be returned\nin the output data.
You should also note that average_rating has been explicitly included\nin the list of values to be returned. This is required because of the\nordering of the values() and annotate() clause.
If the values() clause precedes the annotate() clause, any annotations\nwill be automatically added to the result set. However, if the values()\nclause is applied after the annotate() clause, you need to explicitly\ninclude the aggregate column.
order_by()Link to this heading#Fields that are mentioned in the order_by() part of a queryset (or which\nare used in the default ordering on a model) are used when selecting the\noutput data, even if they are not otherwise specified in the values()\ncall. These extra fields are used to group "like" results together and they\ncan make otherwise identical result rows appear to be separate. This shows up,\nparticularly, when counting things.
By way of example, suppose you have a model like this:
\nfrom django.db import models\n\nclass Item(models.Model):\n name = models.CharField(max_length=10)\n data = models.IntegerField()\n\n class Meta:\n ordering = ["name"]\nThe important part here is the default ordering on the name field. If you\nwant to count how many times each distinct data value appears, you might\ntry this:
# Warning: not quite correct!\nItem.objects.values("data").annotate(Count("id"))\n...which will group the Item objects by their common data values and\nthen count the number of id values in each group. Except that it won't\nquite work. The default ordering by name will also play a part in the\ngrouping, so this query will group by distinct (data, name) pairs, which\nisn't what you want. Instead, you should construct this queryset:
Item.objects.values("data").annotate(Count("id")).order_by()\n...clearing any ordering in the query. You could also order by, say, data\nwithout any harmful effects, since that is already playing a role in the\nquery.
This behavior is the same as that noted in the queryset documentation for\ndistinct() and the general rule is the\nsame: normally you won't want extra columns playing a part in the result, so\nclear out the ordering, or at least make sure it's restricted only to those\nfields you also select in a values() call.
You can also generate an aggregate on the result of an annotation. When you\ndefine an aggregate() clause, the aggregates you provide can reference\nany alias defined as part of an annotate() clause in the query.
For example, if you wanted to calculate the average number of authors per\nbook you first annotate the set of books with the author count, then\naggregate that author count, referencing the annotation field:
\n>>> from django.db.models import Count, Avg\n>>> Book.objects.annotate(num_authors=Count('authors')).aggregate(Avg('num_authors'))\n{'num_authors__avg': 1.66}\n