Comment exprimer une relation One-To-Many dans Django ?

Question

Je suis en train de définir mes modèles Django en ce moment et j'ai réalisé qu'il n'y avait pas de OneToManyField dans les types de champs du modèle. Je suis sûr qu'il y a un moyen de le faire, donc je ne suis pas sûr de ce qui me manque. J'ai essentiellement quelque chose comme ceci :

class Dude(models.Model):
    numbers = models.OneToManyField('PhoneNumber')

class PhoneNumber(models.Model):
    number = models.CharField()

Dans ce cas, chaque Dude peut avoir plusieurs PhoneNumber mais la relation doit être unidirectionnelle, en ce sens que je n'ai pas besoin de savoir de la part du PhoneNumber dont Dude le possède, en tant que tel, car je peux avoir de nombreux objets différents qui possèdent PhoneNumber des instances, telles qu'un Business par exemple :

class Business(models.Model):
    numbers = models.OneToManyField('PhoneNumber')

Que remplacerais-je ? OneToManyField (qui n'existe pas) avec dans le modèle pour représenter ce type de relation ? Je viens de Hibernate/JPA où la déclaration d'une relation un-à-plusieurs était aussi simple que :

@OneToMany
private List<PhoneNumber> phoneNumbers;

Comment puis-je exprimer cela dans Django ?

Answer 1

Pour gérer les relations One-To-Many dans Django, vous devez utiliser ForeignKey .

La documentation sur ForeignKey est très complète et devrait répondre à toutes les questions que vous vous posez :

https://docs.djangoproject.com/en/3.2/ref/models/fields/#foreignkey

La structure actuelle de votre exemple permet à chaque Mec de disposer d'un numéro et à chaque numéro d'appartenir à plusieurs Mecs (idem pour les entreprises).

Si vous souhaitez obtenir la relation inverse, vous devez ajouter deux champs ForeignKey à votre modèle PhoneNumber, un pour Dude et un pour Business. Cela permettrait à chaque numéro d'appartenir soit à un homme, soit à une entreprise, et aux hommes et aux entreprises de posséder plusieurs numéros. Je pense que c'est peut-être ce que vous recherchez.

class Business(models.Model):
    ...
class Dude(models.Model):
    ...
class PhoneNumber(models.Model):
    dude = models.ForeignKey(Dude)
    business = models.ForeignKey(Business)

Answer 2

Dans Django, une relation un-à-plusieurs est appelée ForeignKey. Cependant, elle ne fonctionne que dans un seul sens, donc plutôt que d'avoir une relation de type number attribut de la classe Dude vous aurez besoin de

class Dude(models.Model):
    ...

class PhoneNumber(models.Model):
    dude = models.ForeignKey(Dude)

De nombreux modèles peuvent avoir un ForeignKey à un autre modèle, il serait donc valable d'avoir un deuxième attribut de PhoneNumber de telle sorte que

class Business(models.Model):
    ...
class Dude(models.Model):
    ...
class PhoneNumber(models.Model):
    dude = models.ForeignKey(Dude)
    business = models.ForeignKey(Business)

Vous pouvez accéder à la PhoneNumber s pour un Dude objet d con d.phonenumber_set.objects.all() et faire de même pour a Business objet.

Answer 3

Pour être plus clair - il n'y a pas de OneToMany dans Django, seulement ManyToOne - qui est Foreignkey décrit ci-dessus. Vous pouvez décrire la relation OneToMany en utilisant Foreignkey mais c'est très inexpressif.

Un bon article à ce sujet : https://amir.rachum.com/blog/2013/06/15/a-case-for-a-onetomany-relationship-in-django/

Answer 4

Vous pouvez utiliser l'une ou l'autre clé étrangère sur plusieurs côtés de OneToMany (c'est-à-dire ManyToOne ) ou utiliser ManyToMany (sur n'importe quel côté) avec une contrainte unique.

Answer 5

Django est assez intelligent. En fait, nous n'avons pas besoin de définir oneToMany champ. Il sera automatiquement généré par Django pour vous. Nous avons seulement besoin de définir un foreignKey dans le tableau correspondant. En d'autres termes, nous devons seulement définir ManyToOne en utilisant foreignKey .

class Car(models.Model):
    # wheels = models.oneToMany() to get wheels of this car [**it is not required to define**].

class Wheel(models.Model):
    car = models.ForeignKey(Car, on_delete=models.CASCADE)  

Si nous voulons obtenir la liste des roues d'une voiture particulière, nous utiliserons l'objet généré automatiquement par Python. wheel_set . Pour les voitures c vous utiliserez c.wheel_set.all() .