Wie man eine Eins-zu-Viele-Beziehung in Django ausdrückt

Ich definiere gerade meine Django-Modelle und habe festgestellt, dass es OneToManyFieldin den Modellfeldtypen keine gibt . Ich bin mir sicher, dass es einen Weg gibt, also bin ich mir nicht sicher, was mir fehlt. Ich habe im Wesentlichen so etwas:

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

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

In diesem Fall kann jedes Dudemehrere PhoneNumbers haben, aber die Beziehung sollte unidirektional sein, da ich nicht wissen muss PhoneNumber, Dudewem es per se gehört, da ich möglicherweise viele verschiedene Objekte habe, die PhoneNumberInstanzen besitzen, wie z. B. ein Businessfor Beispiel:

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

Was würde ich OneToManyFieldim Modell ersetzen (was nicht existiert), um diese Art von Beziehung darzustellen? Ich komme aus Hibernate / JPA, wo es so einfach war, eine Eins-zu-Viele-Beziehung zu erklären:

@OneToMany
private List<PhoneNumber> phoneNumbers;

Wie kann ich das in Django ausdrücken?

Um Eins-zu-Viele-Beziehungen in Django zu verwalten, müssen Sie verwenden ForeignKey.

Die Dokumentation zu ForeignKey ist sehr umfassend und sollte alle Ihre Fragen beantworten:

https://docs.djangoproject.com/de/dev/ref/models/fields/#foreignkey

Die aktuelle Struktur in Ihrem Beispiel ermöglicht es jedem Typen, eine Nummer zu haben, und jede Nummer kann mehreren Typen gehören (wie bei Business).

Wenn Sie die umgekehrte Beziehung wünschen, müssen Sie Ihrem PhoneNumber-Modell zwei ForeignKey-Felder hinzufügen, eines für Dude und eines für Business. Dies würde es jeder Nummer ermöglichen, entweder einem Kerl oder einem Unternehmen zu gehören, und Jungs und Unternehmen könnten mehrere Nummern besitzen. Ich denke, das könnte das sein, wonach du suchst.

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

In Django heißt eine Eins-zu-Viele-Beziehung ForeignKey. Es funktioniert jedoch nur in eine Richtung, sodass Sie kein numberKlassenattribut Dudebenötigen

class Dude(models.Model):
    ...

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

Viele Modelle können eine haben , ForeignKeyum ein anderes Modell, so dass es gültig wäre , ein zweites Attribut haben , PhoneNumberso dass

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

Sie können auf das PhoneNumbers für ein DudeObjekt dmit zugreifen d.phonenumber_set.objects.all()und dann für ein BusinessObjekt ähnlich vorgehen.

Um es klarer zu machen - es gibt kein OneToMany in Django, nur ManyToOne - das ist der oben beschriebene Foreignkey. Sie können die OneToMany-Beziehung mit Foreignkey beschreiben, aber das ist sehr unaussprechlich.

Ein guter Artikel dazu: https://amir.rachum.com/blog/2013/06/15/a-case-for-a-onetomany-relationship-in-django/

Sie können entweder Fremdschlüssel auf vielen Seiten der OneToManyBeziehung (dh ManyToOneBeziehung) oder ManyToMany(auf jeder Seite) mit eindeutiger Einschränkung verwenden.

djangoist klug genug. Eigentlich müssen wir kein oneToManyFeld definieren . Es wird automatisch von djangofür Sie generiert :-). Wir müssen nur foreignKeyin der zugehörigen Tabelle definieren . Mit anderen Worten, wir müssen die ManyToOneBeziehung nur mit definieren 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)  

wenn wir die Liste der Räder eines bestimmten Autos erhalten wollen. Wir werden python'sautomatisch generierte Objekte verwenden wheel_set. Für das Auto werden cSie verwendenc.wheel_set.all()

Die Antwort von Rolling Stone ist zwar gut, unkompliziert und funktional, aber ich denke, es gibt zwei Dinge, die es nicht löst.

1. Wenn OP eine Telefonnummer erzwingen wollte, kann sie nicht sowohl einem Kerl als auch einem Unternehmen gehören
2. Das unausweichliche Gefühl der Traurigkeit als Ergebnis der Definition der Beziehung im PhoneNumber-Modell und nicht im Dude / Business-Modell. Wenn zusätzliche Erdbewohner auf die Erde kommen und wir ein Alien-Modell hinzufügen möchten, müssen wir die Telefonnummer ändern (vorausgesetzt, die ETs haben Telefonnummern), anstatt dem Alien-Modell einfach ein Feld "phone_numbers" hinzuzufügen.

Führen Sie das Framework für Inhaltstypen ein , das einige Objekte verfügbar macht, mit denen wir einen "generischen Fremdschlüssel" für das PhoneNumber-Modell erstellen können. Dann können wir die umgekehrte Beziehung für Dude und Business definieren

from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
from django.contrib.contenttypes.models import ContentType
from django.db import models

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

    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    object_id = models.PositiveIntegerField()
    owner = GenericForeignKey()

class Dude(models.Model):
    numbers = GenericRelation(PhoneNumber)

class Business(models.Model):
    numbers = GenericRelation(PhoneNumber)

Weitere Informationen finden Sie in den Dokumenten. In diesem Artikel finden Sie möglicherweise ein kurzes Tutorial.

Hier ist auch ein Artikel , der gegen die Verwendung von generischen FKs spricht.

Wenn das "viele" -Modell die Erstellung eines Modells an sich nicht rechtfertigt (hier nicht der Fall, aber es könnte anderen Menschen zugute kommen), besteht eine andere Alternative darin, sich über das Django Contrib-Paket auf bestimmte PostgreSQL-Datentypen zu verlassen

Postgres kann mit Array- oder JSON- Datentypen umgehen , und dies kann eine gute Problemumgehung für One-to-Many sein, wenn die Many -ies nur an eine einzelne Entität des einen gebunden werden können .

Mit Postgres können Sie auf einzelne Elemente des Arrays zugreifen. Dies bedeutet, dass Abfragen sehr schnell durchgeführt werden können und Overheads auf Anwendungsebene vermieden werden. Und natürlich implementiert Django eine coole API , um diese Funktion zu nutzen.

Es hat offensichtlich den Nachteil, dass es nicht für andere Datenbank-Backends portierbar ist, aber ich denke, es ist immer noch erwähnenswert.

Hoffe, es kann einigen Leuten helfen, nach Ideen zu suchen.

Zunächst machen wir eine Tour:

01) Eins-zu-Viele-Beziehung:

ASSUME:

class Business(models.Model):
    name = models.CharField(max_length=200)
    .........
    .........
    phone_number = models.OneToMany(PhoneNumber) (NB: Django do not support OneToMany relationship)

class Dude(models.Model):
    name = models.CharField(max_length=200)
    .........
    .........
    phone_number = models.OneToMany(PhoneNumber) (NB: Django do not support OneToMany relationship)

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

NB: Django bietet keine OneToMany-Beziehung. Daher können wir in Django keine obere Methode verwenden. Aber wir müssen in ein relationales Modell konvertieren. Also was können wir tun? In dieser Situation müssen wir das relationale Modell in ein umgekehrtes relationales Modell umwandeln.

Hier:

relationales Modell = OneToMany

Also, umgekehrtes relationales Modell = ManyToOne

NB: Django unterstützt die ManyToOne-Beziehung und in Django wird ManyToOne von ForeignKey vertreten.

02) Viele-zu-Eins-Beziehung:

SOLVE:

class Business(models.Model):
    .........
    .........

class Dude(models.Model):
    .........
    .........

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

NB: EINFACH DENKEN !!