Comment interroger en tant que GROUP BY dans Django?

Je recherche un modèle:

Members.objects.all()

Et ça revient:

Eric, Salesman, X-Shop
Freddie, Manager, X2-Shop
Teddy, Salesman, X2-Shop
Sean, Manager, X2-Shop

Ce que je veux, c'est connaître la meilleure façon Django de lancer une group_byrequête dans ma base de données, comme:

Members.objects.all().group_by('designation')

Ce qui ne fonctionne pas, bien sûr. Je sais que nous pouvons faire quelques astuces django/db/models/query.py, mais je suis simplement curieux de savoir comment le faire sans patcher.

Si vous souhaitez effectuer une agrégation, vous pouvez utiliser les fonctionnalités d'agrégation de l'ORM :

from django.db.models import Count
Members.objects.values('designation').annotate(dcount=Count('designation'))

Il en résulte une requête similaire à

SELECT designation, COUNT(designation) AS dcount
FROM members GROUP BY designation

et la sortie serait de la forme

[{'designation': 'Salesman', 'dcount': 2}, 
 {'designation': 'Manager', 'dcount': 2}]

Une solution simple, mais pas la bonne, consiste à utiliser du SQL brut :

results = Members.objects.raw('SELECT * FROM myapp_members GROUP BY designation')

Une autre solution consiste à utiliser la group_bypropriété:

query = Members.objects.all().query
query.group_by = ['designation']
results = QuerySet(query=query, model=Members)

Vous pouvez maintenant parcourir la variable des résultats pour récupérer vos résultats. Notez que cela group_byn'est pas documenté et pourrait être modifié dans la future version de Django.

Et ... pourquoi voulez-vous l'utiliser group_by? Si vous n'utilisez pas d'agrégation, vous pouvez utiliser order_bypour obtenir un résultat similaire.

Vous pouvez également utiliser la regroupbalise de modèle pour regrouper par attributs. De la documentation:

cities = [
    {'name': 'Mumbai', 'population': '19,000,000', 'country': 'India'},
    {'name': 'Calcutta', 'population': '15,000,000', 'country': 'India'},
    {'name': 'New York', 'population': '20,000,000', 'country': 'USA'},
    {'name': 'Chicago', 'population': '7,000,000', 'country': 'USA'},
    {'name': 'Tokyo', 'population': '33,000,000', 'country': 'Japan'},
]

...

{% regroup cities by country as country_list %}

<ul>
    {% for country in country_list %}
        <li>{{ country.grouper }}
            <ul>
            {% for city in country.list %}
                <li>{{ city.name }}: {{ city.population }}</li>
            {% endfor %}
            </ul>
        </li>
    {% endfor %}
</ul>

Ressemble à ça:

• Inde
  • Mumbai: 19 000 000
  • Calcutta: 15 000 000
• Etats-Unis
  • New York: 20 000 000
  • Chicago: 7 000 000
• Japon
  • Tokyo: 33 000 000

Il fonctionne également sur QuerySets je crois.

source: https://docs.djangoproject.com/en/2.1/ref/templates/builtins/#regroup

modifier: notez que la regroupbalise ne fonctionne pas comme vous vous y attendez si votre liste de dictionnaires n'est pas triée par clé. Cela fonctionne de manière itérative. Triez donc votre liste (ou ensemble de requêtes) par la clé du mérou avant de la passer à la regroupbalise.

Vous devez faire du SQL personnalisé comme illustré dans cet extrait:

SQL personnalisé via une sous-requête

Ou dans un gestionnaire personnalisé comme indiqué dans les documents Django en ligne:

Ajout de méthodes Manager supplémentaires

Django ne prend pas en charge les groupes libres par requêtes . Je l'ai appris de très mauvaise façon. ORM n'est pas conçu pour prendre en charge des choses comme ce que vous voulez faire, sans utiliser de SQL personnalisé. Vous êtes limité à:

• SQL RAW (c'est-à-dire MyModel.objects.raw ())
• cr.execute phrases (et une analyse à la main du résultat).
• .annotate() (le regroupement par phrases est effectué dans le modèle enfant pour .annotate (), dans des exemples comme l'agrégation lines_count = Count ('lines'))).

Sur un ensemble de requêtes, qsvous pouvez appeler qs.query.group_by = ['field1', 'field2', ...]mais il est risqué si vous ne savez pas quelle requête éditez-vous et n'avez aucune garantie que cela fonctionnera et ne cassera pas les internes de l'objet QuerySet. De plus, c'est une API interne (non documentée) à laquelle vous ne devez pas accéder directement sans risquer que le code ne soit plus compatible avec les futures versions de Django.

Il existe un module qui vous permet de regrouper les modèles Django et de continuer à travailler avec un QuerySet dans le résultat: https://github.com/kako-nawao/django-group-by

Par exemple:

from django_group_by import GroupByMixin

class BookQuerySet(QuerySet, GroupByMixin):
    pass

class Book(Model):
    title = TextField(...)
    author = ForeignKey(User, ...)
    shop = ForeignKey(Shop, ...)
    price = DecimalField(...)

class GroupedBookListView(PaginationMixin, ListView):
    template_name = 'book/books.html'
    model = Book
    paginate_by = 100

    def get_queryset(self):
        return Book.objects.group_by('title', 'author').annotate(
            shop_count=Count('shop'), price_avg=Avg('price')).order_by(
            'name', 'author').distinct()

    def get_context_data(self, **kwargs):
        return super().get_context_data(total_count=self.get_queryset().count(), **kwargs)

«book / books.html»

<ul>
{% for book in object_list %}
    <li>
        <h2>{{ book.title }}</td>
        <p>{{ book.author.last_name }}, {{ book.author.first_name }}</p>
        <p>{{ book.shop_count }}</p>
        <p>{{ book.price_avg }}</p>
    </li>
{% endfor %}
</ul>

La différence des annotate/ de aggregatebase des requêtes Django est l'utilisation des attributs d'un domaine connexe, par exemple book.author.last_name.

Si vous avez besoin des PK des instances qui ont été regroupées, ajoutez l'annotation suivante:

.annotate(pks=ArrayAgg('id'))

REMARQUE: ArrayAggest une fonction spécifique à Postgres, disponible à partir de Django 1.9: https://docs.djangoproject.com/en/1.10/ref/contrib/postgres/aggregates/#arrayagg

Le document indique que vous pouvez utiliser des valeurs pour regrouper l'ensemble de requêtes.

class Travel(models.Model):
    interest = models.ForeignKey(Interest)
    user = models.ForeignKey(User)
    time = models.DateTimeField(auto_now_add=True)

# Find the travel and group by the interest:

>>> Travel.objects.values('interest').annotate(Count('user'))
<QuerySet [{'interest': 5, 'user__count': 2}, {'interest': 6, 'user__count': 1}]>
# the interest(id=5) had been visited for 2 times, 
# and the interest(id=6) had only been visited for 1 time.

>>> Travel.objects.values('interest').annotate(Count('user', distinct=True)) 
<QuerySet [{'interest': 5, 'user__count': 1}, {'interest': 6, 'user__count': 1}]>
# the interest(id=5) had been visited by only one person (but this person had 
#  visited the interest for 2 times

Vous pouvez trouver tous les livres et les regrouper par nom en utilisant ce code:

Book.objects.values('name').annotate(Count('id')).order_by() # ensure you add the order_by()

Vous pouvez regarder une feuille de cheet ici .

Si je ne me trompe pas, vous pouvez utiliser, quel que soit l'ensemble de requêtes .group_by = [' field ']

from django.db.models import Sum
Members.objects.annotate(total=Sum(designation))

vous devez d'abord importer Sum puis ..