ComhiomlánúLink to this heading#

Comhiomlánú iolracha a churLink to this heading#

<10060>Comhiomlánú iolracha a chomhcheangal le ``annotate () ``beidh: ticket: `na torthaí míchearta mar úsáidtear comhpháirteanna in ionad fo-cheisteanna:

>>> book = Book.objects.first()
>>> book.authors.count()
2
>>> book.store_set.count()
3
>>> q = Book.objects.annotate(Count("authors"), Count("store"))
>>> q[0].authors__count
6
>>> q[0].store__count
6

Maidir le formhór na gcomhiomlánaithe, níl aon bhealach ann chun an fhadhb seo a sheachaint, áfach, tá paraiméadar ``difriúil ``ag comhiomlán:class: ~django.db.models.count a d'fhéadfadh cabhrú le:

>>> q = Book.objects.annotate(
...     Count("authors", distinct=True), Count("store", distinct=True)
... )
>>> q[0].authors__count
2
>>> q[0].store__count
3

Ag leanúint caidrimh ar aisLink to this heading#

Ar bhealach cosúil le:ref: lookups-that-span-reachships, is féidir le comhiomlánú agus anótaí ar réimsí samhlacha nó samhlacha a bhaineann leis an gceann atá á fhiosrú agat caidrimh “droim” a bheith san áireamh. Úsáidtear ainm beaga samhlacha gaolmhara agus béim dhúbailte anseo freisin.

Mar shampla, is féidir linn iarraidh ar gach foilsitheoir, a bhfuil anótáil acu lena gcuntair stoc leabhar iomlána faoi seach (tabhair faoi deara conas a úsáidimid `leabhar chun an Foilsitheoir ``-> `Leabhar eochair eachtrach droim a shonrú):

>>> from django.db.models import Avg, Count, Min, Sum
>>> Publisher.objects.annotate(Count("book"))

(Beidh tréith bhreise ar a dtugtar book__count ag gach Foilsitheoir ``sa `QuerySet` mar thoradh air.)

Is féidir linn an leabhar is sine a iarraidh freisin d'aon cheann de na cinn atá á mbainistiú ag gach foilsitheoir:

>>> Publisher.objects.aggregate(oldest_pubdate=Min("book__pubdate"))

(Beidh eochair ar a dtugtar 'oldest_pubdate' ag an bhfoclóir mar thoradh air. Mura ndéanfaí aon ainm den sórt sin a shonrú, bheadh sé an book__pubdate__min' sách fada.)

Ní bhaineann sé seo ach le heochracha eachtracha. Oibríonn sé freisin le caidreamh go leor. Mar shampla, is féidir linn gach údar a iarraidh, anótáilte le líon iomlán na leathanaigh ag smaoineamh ar na leabhair go léir atá (co-) údar an t-údar (tabhair faoi deara conas a úsáidimid `leabhar chun an Údar -> Leabhar` a shonrú go leor hop):

>>> Author.objects.annotate(total_pages=Sum("book__pages"))

(Beidh tréith bhreise ar a dtugtar total_pages ag gach Údar sa QuerySet` mar thoradh air. Mura ndéanfaí aon ainm den sórt sin a shonrú, bheadh sé an `book__pages__sum ``sách fada.)

Nó iarr meánrátáil na leabhar go léir atá scríofa ag údar (í) atá againn ar chomhad:

>>> Author.objects.aggregate(average_rating=Avg("book__rating"))

(Beidh eochair ar a dtugtar 'average_rating' ag an bhfoclóir mar thoradh air. Mura ndéanfaí aon ainm den sórt sin a shonrú, bheadh sé an book__rating__avg' sách fada.)

scagaire () ``agus ``eisiamh ()Link to this heading#

Is féidir le comhiomlán páirt a ghlacadh i scagairí Beidh éifeacht ag aon scagaire () ``(nó ``eisiamh ()) a chuirtear i bhfeidhm ar ghnáthréimsí samhlacha srian ar na rudaí a mheastar lena chomhiomlánú.

Nuair a úsáidtear é le clásal ``annotate () `, tá éifeacht ag scagaire srian ar na rudaí a ríomhtar anótáil dóibh. Mar shampla, is féidir leat liosta anótaithe a ghiniúint de na leabhair go léir a bhfuil teideal acu ag tosú le “Django” ag baint úsáide as an bhfiosrú:

>>> from django.db.models import Avg, Count
>>> Book.objects.filter(name__startswith="Django").annotate(num_authors=Count("authors"))

Nuair a úsáidtear é le clásal ``comhiomlán () ``, tá éifeacht ag scagaire srian ar na rudaí a ríomhtar an comhiomlán orthu. Mar shampla, is féidir leat meánphraghas gach leabhar a ghiniúint le teideal a thosaíonn le “Django” ag baint úsáide as an gceist:

>>> Book.objects.filter(name__startswith="Django").aggregate(Avg("price"))

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

>>> highly_rated = Count("book", filter=Q(book__rating__gte=7))
>>> Author.objects.annotate(num_books=Count("book"), highly_rated_books=highly_rated)

>>> 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)

>>> 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)

``ord_by () ``Link to this heading#

Is féidir anótaí a úsáid mar bhunús le haghaidh ordú. Nuair a shainmhíníonn tú clásal ``order_by () , is féidir leis na comhiomláin a sholáthraíonn tú tagairt a dhéanamh d'aon ainm a shainmhínítear mar chuid de chlásal ``annotate () sa cheist.

Mar shampla, chun “QuerySet” de leabhair a ordú de réir líon na n-údar a chuir leis an leabhar, d'fhéadfá an cheist seo a leanas a úsáid:

>>> Book.objects.annotate(num_authors=Count("authors")).order_by("num_authors")

``luachanna () ``Link to this heading#

De ghnáth, gintear anótaí ar bhonn in aghaidh an réada - tabharfaidh ``QuerySet` anótáilte toradh amháin ar ais do gach réad sa ``QuerySet` bunaidh. Mar sin féin, nuair a úsáidtear clásal ``luachanna () ``chun srian a chur ar na colúin a chuirtear ar ais sa tacar torthaí, tá an modh chun anótaí a mheas beagán difriúil. In ionad toradh anótaithe a thabhairt ar ais do gach toradh sa “QuerySet” bunaidh, déantar na torthaí bunaidh a ghrúpáil de réir na gcomhcheangail uathúla de na réimsí a shonraítear sa chlásal ``luachanna () ``. Cuirtear anótáil ar fáil ansin do gach grúpa uathúil; ríomhtar an t-anótáil thar gach ball den ghrúpa.

Mar shampla, smaoinigh ar cheist údair a dhéanann iarracht meánrátáil leabhar a scríobh gach údar a fháil amach:

>>> Author.objects.annotate(average_rating=Avg("book__rating"))

Tabharfaidh sé seo toradh amháin ar ais do gach údar sa bhunachar sonraí, anótáilte lena meánrátáil leabhar.

Mar sin féin, beidh an toradh beagán difriúil má úsáideann tú clásal ``luachanna () ``:

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

Sa sampla seo, déanfar na húdair a ghrúpáil de réir ainm, mar sin ní gheobhaidh tú ach toradh anótaithe do gach ainm údair uath* uath*. Ciallaíonn sé seo má tá beirt údar agat leis an ainm céanna, déanfar a dtorthaí a chumasc i dtoradh amháin in aschur na fiosrúcháin; ríomhfar an meán mar an meán thar na leabhair a scríobh an dá údar.

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

from django.db import models


class Item(models.Model):
    name = models.CharField(max_length=10)
    data = models.IntegerField()

items = Item.objects.order_by("name")
# Warning: not quite correct!
items.values("data").annotate(Count("id"))

items.values("data").annotate(Count("id")).order_by()

Anótaí a chomhiomlánúLink to this heading#

Is féidir leat comhiomlán a ghiniúint freisin ar thoradh anótála. Nuair a shainmhíníonn tú clásal ``comhiomlán () ``, is féidir leis na comhiomláin a sholáthraíonn tú tagairt a thabhairt d'aon ainm a shainmhínítear mar chuid de chlásal ``annotate () `sa cheist.

Mar shampla, más mian leat meánlíon na n-údar in aghaidh an leabhair a ríomh déanann tú anótáil ar dtús an tacar leabhar le comhaireamh na n-údair, ansin comhiomlánú an údair sin, ag tagairt don réimse anótála:

>>> from django.db.models import Avg, Count
>>> Book.objects.annotate(num_authors=Count("authors")).aggregate(Avg("num_authors"))
{'num_authors__avg': 1.66}

Comhiomlánú ar cheisteanna nó grúpaí folamhLink to this heading#

<aggregate-default>Nuair a chuirtear comhiomlánú i bhfeidhm ar shraith fiosrúcháin nó grúpáil folamh, déanann an toradh réamhshocraithe ar a pharaiméadar: ref: réamhshocraithe', de ghnáth ``None`. Tarlaíonn an t-iompar seo toisc go bhfilleann feidhmeanna comhiomlánacha NULL nuair a fhaigheann an ceist forghníomhaithe

Is féidir leat luach tuairisceáin a shonrú tríd an argóint: ref: default <aggregate-default>`a sholáthar don chuid is mó de na comhiomlánaithe. <aggregate-default>Mar sin féin, ós rud é nach dtacaíonn: class: `~django.db.models.count leis an argóint: ref: default `, fillfidh sé ``0` i gcónaí le haghaidh ceisteanna folmha nó grúpaí.

Mar shampla, ag glacadh leis nach bhfuil web in ainm ar aon leabhar, ag ríomh an praghas iomlán don tacar leabhar seo ar ais None ós rud é nach bhfuil aon sraitheanna comhoiriúnaithe ann chun an comhiomlán:class: ~django.db.Models.sum a ríomh ar:

>>> from django.db.models import Sum
>>> Book.objects.filter(name__contains="web").aggregate(Sum("price"))
{"price__sum": None}

Mar sin féin, is féidir an argóint:ref: default <aggregate-default>`a shocrú agus tú ag glaoch ar: class: `~django.db.models.sum chun luach réamhshocraithe difriúil a thabhairt ar ais mura féidir aon leabhair a aimsiú:

>>> Book.objects.filter(name__contains="web").aggregate(Sum("price", default=0))
{"price__sum": Decimal("0")}

Faoin gcochall, cuirtear an argóint:ref: default <aggregate-default>`i bhfeidhm tríd an bhfeidhm chomhiomlán a fhilleadh le:class: `~django.db.models.functions.coalesce.

Aggregating with MySQL ONLY_FULL_GROUP_BY enabledLink to this heading#

When using the values() clause to group query results for annotations in MySQL with the ONLY_FULL_GROUP_BY SQL mode enabled, you may need to apply AnyValue if the annotation includes a mix of aggregate and non-aggregate expressions.

Take the following example:

>>> from django.db.models import F, Count, Greatest
>>> Book.objects.values(greatest_pages=Greatest("pages", 600)).annotate(
...     num_authors=Count("authors"),
...     pages_per_author=F("greatest_pages") / F("num_authors"),
... ).aggregate(Avg("pages_per_author"))

This creates groups of books based on the SQL column GREATEST(pages, 600). One unique group consists of books with 600 pages or less, and other unique groups will consist of books with the same pages. The pages_per_author annotation is composed of aggregate and non-aggregate expressions, num_authors is an aggregate expression while greatest_page isn't.

Since the grouping is based on the greatest_pages expression, MySQL may be unable to determine that greatest_pages (used in the pages_per_author expression) is functionally dependent on the grouped column. As a result, it may raise an error like:

OperationalError: (1055, "Expression #2 of SELECT list is not in GROUP BY
clause and contains nonaggregated column 'book_book.pages' which is not
functionally dependent on columns in GROUP BY clause; this is incompatible
with sql_mode=only_full_group_by")

To avoid this, you can wrap the non-aggregate expression with AnyValue.

>>> from django.db.models import AnyValue, F, Count, Greatest
>>> Book.objects.values(
...     greatest_pages=Greatest("pages", 600),
... ).annotate(
...     num_authors=Count("authors"),
...     pages_per_author=AnyValue(F("greatest_pages")) / F("num_authors"),
... ).aggregate(Avg("pages_per_author"))
{'pages_per_author__avg': 532.57143333}

Other supported databases do not encounter the OperationalError in the example above because they can detect the functional dependency. In general, AnyValue is useful when dealing with select list columns that involve non-aggregate functions or complex expressions not recognized by the database as functionally dependent on the columns in the grouping clause.