Come esprimere una relazione uno-a-molti in Django

Sto definendo i miei modelli Django in questo momento e mi sono reso conto che non c'era un OneToManyFieldtipo di campo nel modello. Sono sicuro che c'è un modo per farlo, quindi non sono sicuro di cosa mi sto perdendo. Ho essenzialmente qualcosa del genere:

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

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

In questo caso, ogni Dudepuò avere più PhoneNumbers, ma il rapporto dovrebbe essere unidirezionale, nel senso che non ho bisogno di sapere dal PhoneNumberquale Dudelo possiede, di per sé, come potrei avere molti oggetti diversi che propri PhoneNumbercasi, come ad esempio una Businessper esempio:

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

Cosa sostituirò OneToManyField(che non esiste) nel modello per rappresentare questo tipo di relazione? Vengo da Hibernate / JPA dove dichiarare una relazione uno-a-molti è stato facile come:

@OneToMany
private List<PhoneNumber> phoneNumbers;

Come posso esprimerlo in Django?

Per gestire le relazioni uno-a-molti in Django devi usare ForeignKey.

La documentazione su ForeignKey è molto completa e dovrebbe rispondere a tutte le domande che hai:

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

L'attuale struttura nel tuo esempio consente a ciascun Dude di avere un numero e ciascun numero appartiene a più Dude (lo stesso con Business).

Se si desidera la relazione inversa, è necessario aggiungere due campi ForeignKey al modello PhoneNumber, uno su Dude e uno su Business. Ciò consentirebbe a ciascun numero di appartenere a un Amico o a un Business e avere Dudes e Business in grado di possedere più numeri. Penso che questo potrebbe essere quello che stai cercando.

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

In Django, una relazione uno-a-molti si chiama ForeignKey. Funziona solo in una direzione, tuttavia, piuttosto che avere un numberattributo di classe Dudeche ti servirà

class Dude(models.Model):
    ...

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

Molti modelli possono avere un ForeignKeyaltro modello, quindi sarebbe valido avere un secondo attributo di PhoneNumbertale

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

Puoi accedere a PhoneNumbers per un Dudeoggetto dcon d.phonenumber_set.objects.all(), quindi fare lo stesso per un Businessoggetto.

Per essere più chiari - non c'è OneToMany in Django, solo ManyToOne - che è la chiave straniera sopra descritta. Puoi descrivere la relazione OneToMany usando Foreignkey ma è molto inespressivo.

Un buon articolo a riguardo: https://amir.rachum.com/blog/2013/06/15/a-case-for-a-onetomany-relationship-in-django/

È possibile utilizzare una chiave esterna su molti lati della OneToManyrelazione (ad es. ManyToOneRelazione) o utilizzare ManyToMany(su qualsiasi lato) con vincolo univoco.

djangoè abbastanza intelligente. In realtà non è necessario definire il oneToManycampo. Verrà generato automaticamente da djangoper te :-). Dobbiamo solo definire foreignKeynella tabella correlata. In altre parole, dobbiamo solo definire la ManyToOnerelazione usando 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)  

se vogliamo ottenere l'elenco delle ruote di un'auto particolare. useremo python'sl'oggetto generato automaticamente wheel_set. Per l'auto cche useretec.wheel_set.all()

Mentre la risposta di rolling stone è buona, diretta e funzionale, penso che ci siano due cose che non risolve.

1. Se OP voleva far rispettare un numero di telefono non può appartenere sia a un Amico che a un Business
2. L'inevitabile sensazione di tristezza derivante dalla definizione della relazione sul modello PhoneNumber e non sui modelli Dude / Business. Quando altri terrestri arrivano sulla Terra e vogliamo aggiungere un modello Alien, dobbiamo modificare il PhoneNumber (supponendo che gli ET abbiano numeri di telefono) invece di aggiungere semplicemente un campo "phone_numbers" al modello Alien.

Introdurre il framework dei tipi di contenuto , che espone alcuni oggetti che ci consentono di creare una "chiave esterna generica" ​​sul modello PhoneNumber. Quindi, possiamo definire la relazione inversa su Dude and Business

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)

Consulta i documenti per i dettagli e forse consulta questo articolo per un breve tutorial.

Inoltre, ecco un articolo che contesta l'uso di FK generici.

Se il modello "molti" non giustifica la creazione di un modello di per sé (non è il caso qui, ma potrebbe andare a beneficio di altre persone), un'altra alternativa sarebbe affidarsi a tipi di dati PostgreSQL specifici, tramite il pacchetto Django Contrib

Postgres può trattare con Array o JSON tipi di dati , e questa può essere una bella soluzione per gestire One-To-Many quando i molti possono essere collegati a un'unica entità di quello .

Postgres ti consente di accedere a singoli elementi dell'array, il che significa che le query possono essere molto veloci ed evitare le spese generali a livello di applicazione. E, naturalmente, Django implementa una fantastica API per sfruttare questa funzionalità.

Ovviamente ha lo svantaggio di non essere portabile sul backend di altri database, ma ho pensato che valesse la pena menzionarlo.

Spero che possa aiutare alcune persone a cercare idee.

Prima di tutto facciamo un tour:

01) relazione uno-a-molti:

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 non fornisce alcuna relazione OneToMany. Quindi non possiamo usare il metodo superiore in Django. Ma dobbiamo convertirci in modello relazionale. Quindi cosa possiamo fare? In questa situazione dobbiamo convertire il modello relazionale in modello relazionale inverso.

Qui:

modello relazionale = OneToMany

Quindi, modello relazionale inverso = ManyToOne

NB: Django supporta la relazione ManyToOne e in Django ManyToOne è rappresentato da ForeignKey.

02) relazione molti-a-uno:

SOLVE:

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

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

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

NB: PENSI SEMPLICEMENTE !!