# Documentation Django 5.2.8

# Agrégation

Le guide thématique sur l’API d’abstraction de base de données de Django décrit la façon dont les requêtes Django peuvent être utilisées pour créer, récupérer, mettre à jour et supprimer des objets individuels. Il est cependant parfois nécessaire de récupérer des valeurs dérivées du résumé ou de l”agrégation d’une collection d’objets. Ce guide thématique décrit la manière dont des valeurs agrégées peuvent être générées et renvoyées en utilisant des requêtes Django.

Tout au long de ce guide, nous nous référerons aux modèles suivants. Ces modèles sont utilisés pour gérer l’inventaire d’une série de bibliothèques en ligne :

    from django.db import models

    class Author(models.Model):
        name = models.CharField(max_length=100)
        age = models.IntegerField()

    class Publisher(models.Model):
        name = models.CharField(max_length=300)

    class Book(models.Model):
        name = models.CharField(max_length=300)
        pages = models.IntegerField()
        price = models.DecimalField(max_digits=10, decimal_places=2)
        rating = models.FloatField()
        authors = models.ManyToManyField(Author)
        publisher = models.ForeignKey(Publisher, on_delete=models.CASCADE)
        pubdate = models.DateField()

    class Store(models.Model):
        name = models.CharField(max_length=300)
        books = models.ManyToManyField(Book)

## Antisèche

Vous êtes pressé ? Voici comment effectuer des requêtes avec agrégation, sur la base des modèles ci-dessus :

    # Total number of books.
    >>> Book.objects.count()
    2452

    # Total number of books with publisher=BaloneyPress
    >>> Book.objects.filter(publisher__name="BaloneyPress").count()
    73

    # Average price across all books, provide default to be returned instead
    # of None if no books exist.
    >>> from django.db.models import Avg
    >>> Book.objects.aggregate(Avg("price", default=0))
    {'price__avg': 34.35}

    # Max price across all books, provide default to be returned instead of
    # None if no books exist.
    >>> from django.db.models import Max
    >>> Book.objects.aggregate(Max("price", default=0))
    {'price__max': Decimal('81.20')}

    # Difference between the highest priced book and the average price of all books.
    >>> from django.db.models import FloatField
    >>> Book.objects.aggregate(
    ...     price_diff=Max("price", output_field=FloatField()) - Avg("price")
    ... )
    {'price_diff': 46.85}

    # All the following queries involve traversing the 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

    # Each publisher, with a separate count of books with a rating above and below 5
    >>> from django.db.models import Q
    >>> above_5 = Count("book", filter=Q(book__rating__gt=5))
    >>> below_5 = Count("book", filter=Q(book__rating__lte=5))
    >>> pubs = Publisher.objects.annotate(below_5=below_5).annotate(above_5=above_5)
    >>> pubs[0].above_5
    23
    >>> pubs[0].below_5
    12

    # 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

## Génération de requêtes d’agrégation sur un objet `QuerySet`

Django propose deux manières de générer des agrégations. La première est de générer un résumé des valeurs d’un `QuerySet` entier. Par exemple, admettons que vous vouliez calculer le prix moyen de tous les livres disponibles à la vente. La syntaxe de requêtes de Django fournit une façon de décrire l’ensemble de tous les livres :

    >>> Book.objects.all()

Ce dont nous avons besoin, c’est d’une manière de calculer un résumé des valeurs de tous les objets appartenant à ce `QuerySet`. Cela se fait en ajoutant une clause `aggregate()` à la suite de l’objet `QuerySet`:

    >>> from django.db.models import Avg
    >>> Book.objects.all().aggregate(Avg("price"))
    {'price__avg': 34.35}

Dans cet exemple, `all()` est redondant, cela pourrait donc être simplifié en écrivant :

    >>> Book.objects.aggregate(Avg("price"))
    {'price__avg': 34.35}

Le paramètre de la clause `aggregate()` décrit la valeur d’agrégation que vous souhaitez calculer, dans ce cas la moyenne du champ `price` du modèle `Book`. Une liste des fonctions d’agrégation disponibles se trouve dans la référence de QuerySet.

`aggregate()` est la clause terminale d’un objet `QuerySet` qui, lorsqu’il est évalué, renvoie un dictionnaire de paires nom-valeur. Le nom est un identifiant de la valeur agrégée ; la valeur est le résultat du calcul d’agrégation. Le nom est généré automatiquement à partir du nom du champ et de la fonction d’agrégation. Si vous voulez indiquer manuellement le nom de la valeur agrégée, vous pouvez le faire en précisant ce nom dans la clause d’agrégation :

    >>> Book.objects.aggregate(average_price=Avg("price"))
    {'average_price': 34.35}

Si vous voulez générer plus d’une valeur agrégée, ajoutez un autre paramètre dans la clause `aggregate()`. Ainsi, si nous voulions aussi connaître les prix maximaux et minimaux de tous les livres, nous écririons la requête suivante :

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

## Génération de valeurs agrégées pour chaque élément d’un `QuerySet`

La deuxième manière de générer des valeurs récapitulatives est de générer un récapitulatif individuel pour chaque objet d’un `QuerySet`. Par exemple, si vous récupérez une liste de livres, il peut être utile de connaître le nombre d’auteurs ayant contribué à chaque livre. Chaque objet `Book` possède une relation plusieurs-à-plusieurs vers le modèle `Author`; nous voulons récapituler cette relation pour chaque livre de la requête.

Les récapitulatifs par objet peuvent être générés par la clause `annotate()`. Lorsque celle-ci est mentionnée, chaque objet de la requête est annoté avec les valeurs indiquées.

La syntaxe de ces annotations est identique à celle utilisée pour les clauses `aggregate()`. Chaque paramètre d”`annotate()` décrit une valeur agrégée à calculer. Par exemple, pour annoter les livres avec le nombre de leurs auteurs :

    # Build an annotated queryset
    >>> from django.db.models import Count
    >>> q = Book.objects.annotate(Count("authors"))
    # Interrogate the first object in the queryset
    >>> q[0]
    <Book: The Definitive Guide to Django>
    >>> q[0].authors__count
    2
    # Interrogate the second object in the queryset
    >>> q[1]
    <Book: Practical Django Projects>
    >>> q[1].authors__count
    1

Comme pour `aggregate()`, le nom de l’annotation est automatiquement dérivé du nom de la fonction d’agrégation et du nom du champ sur lequel se fait le calcul. Vous pouvez surcharger ce nom par défaut en fournissant un alias lors de la définition de l’annotation :

    >>> q = Book.objects.annotate(num_authors=Count("authors"))
    >>> q[0].num_authors
    2
    >>> q[1].num_authors
    1

Au contraire de `aggregate()`, `annotate()` n’est pas une clause terminale. Le résultat de la clause `annotate()` est un objet `QuerySet`. Cet objet peut très bien être modifié par une autre opération de type `QuerySet`, comme par exemple `filter()`, `order_by()` ou même d’autres appels à `annotate()`.

### Combinaison de plusieurs agrégations

La combinaison de plusieurs agrégations avec `annotate()` produit un mauvais résultat, car des jointures sont utilisées à la place de sous-requêtes :

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

Pour la plupart des agrégations, il n’existe pas de solution à ce problème. Cependant, l’agrégation `Count` possède un paramètre `distinct` qui peut être utile :

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

En cas de doute, inspectez la requête SQL !

Afin de comprendre ce qui se produit dans la requête, il est possible d’examiner la propriété `query` de l’objet `QuerySet`.

## Jointures et agrégations

Jusqu’ici, nous avons eu affaire à des agrégations sur des champs appartenant au modèle sur lequel portait la requête. Cependant, la valeur à agréger peut parfois appartenir à un modèle qui est lié au modèle sur lequel porte la requête.

Lors de la définition du champ à agréger dans une fonction d’agrégation, Django permet d’utiliser la même notation de double soulignement qui est utilisée pour se référer aux champs liés dans les filtres. Django se charge ensuite des jointures de tables nécessaires pour récupérer et agréger la valeur liée.

Par exemple, pour trouver l’intervalle des prix pratiqués dans chaque magasin, vous pourriez utiliser l’annotation :

    >>> from django.db.models import Max, Min
    >>> Store.objects.annotate(min_price=Min("books__price"), max_price=Max("books__price"))

Ceci indique à Django de récupérer le modèle `Store`, de faire la jointure avec le modèle `Book` (par la relation plusieurs-à-plusieurs) et d’agréger sur le champ du prix du modèle `Book` pour produire les valeurs du minimum et du maximum.

Les mêmes règles s’appliquent à la clause `aggregate()`. Si vous vouliez connaître le prix le plus bas et le prix le plus haut de tous les livres mis en vente dans n’importe quel magasin, vous pourriez utiliser la fonction d’agrégation :

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

Les chaînes de jointure peuvent être aussi profondes que nécessaire. Par exemple, pour extraire l’âge du plus jeune auteur de tous les livres mis en vente, vous pourriez effectuer la requête :

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

### Suivi des relations inverses

D’une manière similaire aux Recherches traversant les relations, les agrégations et les annotations sur les champs de modèles ou sur les modèles liés à celui sur lequel porte la requête peuvent contenir des relations « inverses » traversantes. Ici également, il est possible d’utiliser la syntaxe des noms en minuscules des modèles liés et des doubles soulignements.

Par exemple, il est possible d’extraire tous les éditeurs annotés avec leur décompte respectif de tous leurs livres publiés (notez la manière d’utiliser `'book'` pour définir la relation de clé étrangère inversée) :

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

(chaque `Publisher` du jeu de requête résultant possédera un attribut supplémentaire nommé `book__count`)

Une autre requête pourrait porter sur le plus ancien livre publié par chaque éditeur :

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

Le dictionnaire résultant possédera une clé nommée `'oldest_pubdate'`. Si l’alias n’avait pas été précisé, cette clé se serait appelée `'book__pubdate__min'`, ce qui est plutôt long.

Cela ne s’applique pas seulement aux clés étrangères, mais fonctionne aussi avec les relations plusieurs-à-plusieurs. Par exemple, nous pouvons rechercher tous les auteurs annotés avec le nombre total de pages de tous les livres pour lesquels ils ont été (co-)auteurs (notez la manière d’utiliser `'book'` pour définir la relation plusieurs-à-plusieurs inversée de `Author` vers `Book`) :

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

Chaque `Author` du jeu de requête résultant possédera un attribut supplémentaire nommé `total_pages`. Si l’alias n’avait pas été précisé, cette clé se serait appelée `'book__pages__sum'`, ce qui est plutôt long.

Nous pourrions encore extraire la moyenne des notes de tous les livres écrits par les auteurs enregistrés :

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

Le dictionnaire résultant possédera une clé nommée `'average_rating'`. Si l’alias n’avait pas été précisé, cette clé se serait appelée `'book__rating__avg'`, ce qui est plutôt long.

## Agrégations et autres clauses de `QuerySet`

### `filter()` et `exclude()`

Les agrégations peuvent aussi intervenir dans les filtres. Toute méthode `filter()` (ou `exclude()`) appliquée à des champs de modèle normaux fera l’effet de restreindre les objets concernés par l’agrégation.

Lorsqu’il est combiné à une clause `annotate()`, un filtre fait l’effet de restreindre les objets sur lesquels l’annotation est calculée. Par exemple, vous pouvez générer une liste annotée de tous les livres ayant leur titre commençant par « Django » à l’aide de la requête :

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

Lorsqu’il est combiné à une clause `aggregate()`, un filtre fait l’effet de restreindre les objets sur lesquels l’agrégation est calculée. Par exemple, vous pouvez générer le prix moyen de tous les livres ayant leur titre commençant par « Django » à l’aide de la requête :

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

#### Filtrage sur les annotations

Les valeurs annotées peuvent également être filtrées. L’alias de l’annotation peut être utilisé dans les clauses `filter()` et `exclude()` de la même manière que pour n’importe quel autre champ de modèle.

Par exemple, pour générer une liste de livres ayant plus d’un auteur, vous pouvez écrire la requête :

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

Cette requête génère un jeu de requête annoté, puis filtre le résultat sur la base de l’annotation.

Si vous avez besoin de deux annotations avec deux filtres séparés, vous pouvez utiliser le paramètre `filter` avec n’importe quel agrégat. Par exemple, pour générer une liste d’auteurs avec le décompte des livres bien notés :

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

Chaque `Author` dans le jeu de résultats possédera les deux attributs `num_books` et `highly_rated_books`. Voir aussi Agrégation conditionnelle.

Choix entre `filter` et `QuerySet.filter()`

Évitez d’utiliser le paramètre `filter` avec une seule annotation ou agrégation. Il est plus efficace d’utiliser `QuerySet.filter()` pour exclure des lignes. Le paramètre d’agrégation `filter` n’est utile que lorsqu’on utilise au moins deux agrégations sur les mêmes relations avec des conditions différentes.

#### Ordre des clauses `annotate()` et `filter()`

Lors de la rédaction de requête complexe impliquant à la fois des clauses `annotate()` et `filter()`, une attention particulière doit être donnée à l’ordre dans lequel les clauses sont appliquées à l’objet `QuerySet`.

Lorsqu’une clause `annotate()` est appliquée à une requête, l’annotation est calculée sur l’état de la requête au point exact où l’annotation est demandée. L’implication pratique de ceci est que `filter()` et `annotate()` ne sont pas des opérations commutatives.

Étant donné :

- Un « Publisher » A possède deux livres avec notations 4 et 5.

- Un « Publisher » B possède deux livres avec notations 1 et 4.

- Un « Publisher » A possède un livre avec notation 1.

Voici un exemple avec l’agrégation `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)

Les deux requêtes renvoient une liste d’objets « Publisher » ayant au moins un livre avec une note dépassant 3.0, ce qui fait que Publisher C est exclu.

Dans la première requête, l’annotation précède le filtre, ce qui fait que le filtre n’a aucun effet sur l’annotation. `distinct=True` est obligatoire pour éviter une anomalie de requête.

La seconde requête compte le nombre de livres ayant une note dépassant 3.0 pour chaque Publisher. Le filtre précède l’annotation, ce qui fait que le filtre limite les objets pris en compte lors du calcul de l’annotation.

Voici un autre exemple avec l’agrégation `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)

La première requête calcule la note moyenne de tous les livres de chaque éditeur pour les éditeurs ayant au moins un livre avec une note dépassant 3.0. La seconde requête calcule la moyenne des notes des livres d’un éditeur pour tous les livres dont la note dépasse 3.0.

Il est difficile de deviner comment l’ORM va traduire des jeux de requêtes complexes en instructions SQL ; en cas de doute, inspectez le code SQL produit avec `str(queryset.query)` et écrivez de nombreux tests.

### `order_by()`

Les annotations peuvent être utilisées comme base de tri. Lorsque vous définissez une clause `order_by()`, les agrégations que vous indiquez peuvent référencer n’importe quel alias défini dans le cadre d’une clause `annotate()` de la requête.

Par exemple, pour trier un jeu de requête de livres par le nombre d’auteurs ayant contribué au livre, vous pourriez écrire la requête suivante :

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

### `values()`

En principe, les annotations sont générées pour chaque objet ; un jeu de requête annoté renvoie un résultat par objet du jeu de requête original. Cependant, lorsqu’une clause `values()` est utilisée pour restreindre les colonnes renvoyées dans le jeu de requête, la méthode d’évaluation des annotations est légèrement différente. Au lieu de renvoyer un résultat annoté pour chaque résultat du jeu de requête original, les résultats d’origine sont groupés selon les combinaisons uniques des champs indiqués dans la clause `values()`. Puis l’annotation est fournie pour chaque groupe unique ; l’annotation est donc calculée sur tous les membres du groupe.

Par exemple, considérons une requête sur les auteurs cherchant à trouver la moyenne des notes des livres écrits par chaque auteur :

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

Ceci renvoie un résultat pour chaque auteur de la base de données, annoté par la note moyenne de leurs livres.

Cependant, le résultat sera légèrement différent si vous utilisez une clause `values()`:

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

Dans cet exemple, les auteurs sont groupés par nom, vous allez donc obtenir un résultat annoté pour chaque nom d’auteur unique. Cela signifie que si vous avez deux auteurs de même nom, leurs résultats seront fusionnés en un seul dans la requête résultante ; la moyenne sera calculée sur tous les livres écrits par les deux auteurs.

#### Ordre des clauses `annotate()` et `values()`

Comme pour la clause `filter()`, l’ordre d’apparition des clauses `annotate()` et `values()` dans une requête est important. Si la clause `values()` précède `annotate()`, l’annotation est calculée par rapport aux groupements définis par la clause `values()`.

Cependant, si la clause `annotate()` précède la clause `values()`, les annotations sont générées sur la totalité du jeu de requête. Dans ce cas, la clause `values()` ne restreint que les champs dans le résultat final.

Par exemple, si nous inversons l’ordre des clauses `values()` et `annotate()` dans notre exemple précédent :

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

Cela produit maintenant un résultat unique pour chaque auteur ; cependant, seuls le nom de l’auteur et l’annotation `average_rating` sont renvoyés dans les données de résultat.

Remarquez également que `average_rating` a été explicitement inclus dans la liste des valeurs à renvoyer. C’est obligatoire à cause de l’ordre des clauses `values()` et `annotate()`.

Si la clause `values()` précède la clause `annotate()`, toute annotation sera automatiquement ajoutée au résultat de la requête. Toutefois, si la clause `values()` est appliquée après la clause `annotate()`, vous devez inclure explicitement la colonne agrégée.

#### Interaction avec `order_by()`

Les champs mentionnés dans la partie `order_by()` d’une requête sont utilisés lors de la sélection des données du résultat, même s’ils ne sont pas spécifiés explicitement dans l’appel à `values()`. Ces champs supplémentaires sont aussi pris en compte pour regrouper les résultats similaires et peuvent faire apparaître de manière distincte des lignes qui seraient regroupées sans la présence de ces champs. C’est particulièrement flagrant lorsqu’il s’agit de compter des objets.

Pour fournir un exemple, supposons que vous ayez un modèle comme celui-ci :

    from django.db import models

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

Si vous souhaitez compter le nombre d’apparitions distinctes de la valeur `data` dans une requête triée, vous pourriez écrire ceci :

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

…ce qui regroupe les objets `Item` par leurs valeurs `data` communes, puis compte le nombre de valeurs `id` dans chaque groupe. Sauf que ça ne marchera pas comme prévu. Le tri selon `name` intervient aussi dans le regroupement, ce qui fait que la requête regroupe sur les paires distinctes `(data, name)`, ce qui ne correspond pas à l’intention de départ. Voici en réalité ce qu’il faut écrire pour obtenir la requête espérée :

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

…effaçant ainsi tout ordre de tri dans la requête. Il serait aussi possible de trier sur le champ `data` sans conséquence néfaste, dans la mesure où ce champ est déjà impliqué dans la requête.

Ce comportement est le même que ce qui est noté dans la documentation des requêtes concernant `distinct()`, la règle générale étant identique : il n’est normalement pas souhaité que des colonnes supplémentaires soient inclues dans le résultat, il faut donc effacer l’ordre de tri ou en tout cas s’assurer que les champs de tri sont déjà impliqués dans l’appel à `values()`.

Note

You might reasonably ask why Django doesn’t remove the extraneous columns for you. The main reason is consistency with `distinct()` and other places: Django never removes ordering constraints that you have specified explicitly with `order_by()` (and we can’t change those other methods” behavior, as that would violate our Stabilité de l’API policy).

Default ordering not applied to GROUP BY

`GROUP BY` queries (for example, those using `.values()` and `.annotate()`) don’t use the model’s default ordering. Use `order_by()` explicitly when a given order is needed.

### Agrégation des annotations

Vous pouvez aussi générer une agrégation des résultats d’une annotation. Lorsque vous définissez une clause `aggregate()`, cette agrégation peut se référer à n’importe quel alias défini dans une clause `annotate()` de la même requête.

Par exemple, si vous souhaitiez calculer le nombre moyen d’auteurs par livre, vous annoteriez premièrement les livres avec le nombre d’auteurs, puis vous agrégeriez ce nombre en vous référant au champ annoté :

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

### Agrégation sur les jeux de requête ou groupes vides

Lorsqu’un agrégat est appliqué à un jeu de requête ou à un groupe vide, le résultat correspond par défaut à son paramètre default, typiquement `None`. Ce comportement est dû au fait que les fonctions d’agrégat renvoient `NULL` lorsque la requête exécutée ne renvoie aucune ligne.

Vous pouvez indiquer une valeur de renvoi en indiquant un argument default pour la plupart des agrégats. Cependant, comme `Count` n’accepte pas l’argument default, il renverra toujours `0` pour les jeux de requête ou les groupes vides.

Par exemple, en supposant qu’aucun livre ne contienne web dans son nom, le calcul du prix total de cet ensemble de livres renverra `None` du moment où il n’existe aucune ligne pour servir de calcul à l’agrégat `Sum`:

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

Cependant, l’argument default peut être défini lors de l’appel à `Sum` pour renvoyer une valeur différente si aucun livre n’est trouvé :

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

En arrière-plan, l’argument default est implémenté en enveloppant la fonction d’agrégat dans la fonction `Coalesce`.

### Aggregating with MySQL `ONLY_FULL_GROUP_BY` enabled

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

Changed in Django 6.0:

The `AnyValue` aggregate was added.