Comment vous joindre deux tables sur un champ de clé étrangère à l'aide de l'ORM de django?

Supposons que j'ai les modèles suivants:

class Position(models.Model):
    name = models.CharField()

class PositionStats(models.Model):
    position = models.ForeignKey(Position)
    averageYards = models.CharField()
    averageCatches = models.CharField()

class PlayerStats(models.Model):
    player = models.ForeignKey(Player)
    averageYards = models.CharField()
    averageCatches = models.CharField()

class Player(models.Model):
    name = models.CharField()
    position = models.ForeignKey(Position)

Je veux effectuer l'équivalent d'une requête SQL à l'aide de l'ORM de django:

SELECT *

FROM PlayerStats

JOIN Player ON player

JOIN PositionStats ON PositionStats.position = Player.position

Comment pourrais-je le faire avec l'ORM de django? La requête n'est pas tout à fait correcte, mais l'idée est que je veux une seule requête, à l'aide de l'ORM de django, qui me donne PlayerStats rejoint avec PositionStats basé sur la position du joueur.

OriginalL'auteur Lee Schmidt | 2012-10-26

8

Il n'en est pas une requête, mais c'est assez efficace. Ce n'est qu'une seule requête pour chaque table impliqués, et se joint à eux en Python. Plus sur prefetch_related ici: https://docs.djangoproject.com/en/dev/ref/models/querysets/#prefetch-related
```
Player.objects.filter(name="Bob").prefetch_related(
        'position__positionstats_set', 'playerstats_set')
```
OriginalL'auteur dokkaebi
6

J'ai travaillé avec django pour un certain temps maintenant et j'ai eu un peu brutale temps à essayer de comprendre les jointures de table, mais je pense que j'ai enfin compris et je tiens à les transmettre à d'autres, afin d'éviter la frustration que j'ai eu avec elle.

Considérer les points suivants model.py:
```
class EventsMeetinglocation(models.Model):
    id = models.IntegerField(primary_key=True)
    name = models.CharField(max_length=100)
    address = models.CharField(max_length=200)

    class Meta:
        managed = True
        db_table = 'events_meetinglocation'


class EventsBoardmeeting(models.Model):
    id = models.IntegerField(primary_key=True)
    date = models.DateTimeField()
    agenda_id = models.IntegerField(blank=True, null=True)
    location_id = models.ForeignKey(EventsMeetinglocation)
    minutes_id = models.IntegerField(blank=True, null=True)

    class Meta:
       managed = True
       db_table = 'events_boardmeeting'
```
Ici, nous pouvons voir que location_id dans EventsBoardmeeting est une clé étrangère pour l'id dans EventsMeetinglocation. Cela signifie que nous devrions être en mesure de rechercher l'information dans EventsMeetinglocation en passant par EventsBoardmeeting.

Maintenant considérer les points suivants views.py:
```
def meetings(request):
    meetingData = EventsBoardmeeting.objects.all()
    return render(request, 'board/meetings.html', {'data': meetingData })
```
Comme indiqué à plusieurs reprises avant dans d'autres postes, django prend en charge les jointures automatiquement. Lorsque nous requête tout en EventsBoardmeeting nous avons également obtenir toutes les informations connexes par clé étrangère, Mais la façon dont on accède au langage html est un peu différent. Nous devons aller par le biais de la variable utilisée comme clé étrangère d'accéder à l'information associée à cette jointure. Par exemple:
```
{% for x in data %}
   {{ x.location_id.name }}
{% endfor %}
```
Les références ci-dessus, TOUS les noms de la table qui ont été le résultat de la jointure sur la clé étrangère. x est essentiellement le EventsBoardmeeting de la table, de sorte que lorsque nous avons accès à x.location_id nous sommes accéder à la clé étrangère qui nous donne accès à l'information dans EventsMeetinglocation.

OriginalL'auteur Connar Stone
4

select_related() et prefetch_related() est votre solution. Ils fonctionnent presque de la même façon, mais a une certaine différence.

select_related() passe par la création d'une jointure SQL et y compris dans les domaines de l'objet dans l'instruction SELECT. Pour cette raison, select_related obtient les objets liés dans la même requête de base de données. Mais elle ne fonctionne que pour un-à-un ou un-à-plusieurs. Exemple ci-dessous-
```
entry = Entry.objects.select_related('blog').get(id=5)
or
entries = Entry.objects.filter(foo='bar').select_related('blog')
```
prefetch_related(), d'autre part, une recherche distincte pour chaque relation et le "joignant" en Python. Cela permet de prefetch plusieurs-à-plusieurs et plusieurs-à-un les objets, qui ne peut être fait en utilisant select_related. Donc prefetch_related exécutera qu'une seule requête pour chaque relation. L'exemple est donné ci-dessous-
```
Pizza.objects.all().prefetch_related('toppings')
```
OriginalL'auteur Emdadul Sawon
0

De django.db importation d'une connexion Dans votre vue d'inclure la déclaration ci-dessous:
```
cursor = connection.cursor()
cursor.execute("select * From Postion ON Position.name = Player.position JOIN
PlayerStats ON Player.name = 
PlayerStats.player JOIN PositionStats ON Position.name = PositionStats.player")
solution = cursor.fetchall()
```
OP mentionne expressément les "je veux effectuer l'équivalent d'une requête SQL à l'aide de l'ORM de django". Cette réponse donne le SQL brut moyen de le faire, sans l'aide de l'ORM.

OriginalL'auteur user2610811

Vous devez vous connecter pour publier un commentaire.