Bagaimana cara mengekspresikan hubungan Satu-ke-Banyak di Django

Saya mendefinisikan model Django saya sekarang dan saya menyadari bahwa tidak ada OneToManyFielddalam jenis bidang model. Saya yakin ada cara untuk melakukan ini, jadi saya tidak yakin apa yang saya lewatkan. Saya pada dasarnya memiliki sesuatu seperti ini:

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

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

Dalam hal ini, masing Dude- masing dapat memiliki beberapa PhoneNumbers, tetapi hubungannya harus searah, karena saya tidak perlu tahu dari PhoneNumberyang Dudememilikinya, karena saya mungkin memiliki banyak objek berbeda yang memiliki PhoneNumberinstance, seperti Businessuntuk contoh:

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

Apa yang akan saya ganti OneToManyField(yang tidak ada) dengan model untuk mewakili hubungan semacam ini? Saya berasal dari Hibernate / JPA tempat mendeklarasikan hubungan satu-ke-banyak semudah:

@OneToMany
private List<PhoneNumber> phoneNumbers;

Bagaimana saya bisa mengekspresikan ini dalam Django?

Untuk menangani hubungan One-To-Many di Django yang perlu Anda gunakan ForeignKey.

Dokumentasi tentang ForeignKey sangat komprehensif dan harus menjawab semua pertanyaan yang Anda miliki:

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

Struktur saat ini dalam contoh Anda memungkinkan setiap Bung memiliki satu nomor, dan setiap nomor menjadi milik beberapa Dudes (sama dengan Bisnis).

Jika Anda ingin hubungan terbalik, Anda perlu menambahkan dua bidang ForeignKey ke model PhoneNumber Anda, satu ke Dude dan satu ke Bisnis. Ini akan memungkinkan setiap nomor menjadi milik salah satu Dude atau satu Bisnis, dan memiliki Dudes dan Bisnis dapat memiliki beberapa Angka. Saya pikir ini mungkin yang Anda cari.

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

Di Django, hubungan satu-ke-banyak disebut ForeignKey. Namun, ini hanya bekerja dalam satu arah, daripada memiliki numberatribut kelas yang DudeAnda perlukan

class Dude(models.Model):
    ...

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

Banyak model dapat memiliki satu ForeignKeyke model lain, sehingga akan valid untuk memiliki atribut kedua PhoneNumberseperti itu

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

Anda dapat mengakses PhoneNumbers untuk Dudeobjek ddengan d.phonenumber_set.objects.all(), dan kemudian melakukan hal yang sama untuk Businessobjek.

Untuk lebih jelas - tidak ada OneToMany di Django, hanya ManyToOne - yang dijelaskan Foreignkey di atas. Anda bisa mendeskripsikan relasi OneToMany menggunakan Foreignkey tapi itu sangat tidak ekspresif.

Artikel bagus tentang itu: https://amir.rachum.com/blog/2013/06/15/a-case-for-a-onetomany-relationship-in-django/

Anda dapat menggunakan kunci asing di banyak sisi OneToManyhubungan (yaitu ManyToOnehubungan) atau menggunakan ManyToMany(di sisi mana pun) dengan batasan unik.

djangocukup pintar. Sebenarnya kita tidak perlu mendefinisikan oneToManybidang. Ini akan secara otomatis dihasilkan oleh djangountuk Anda :-). Kita hanya perlu mendefinisikan foreignKeydalam tabel terkait. Dengan kata lain, kita hanya perlu mendefinisikan ManyToOnerelasi dengan menggunakan 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)  

jika kita ingin mendapatkan daftar roda mobil tertentu. kita akan menggunakan python'sobjek yang dibuat secara otomatis wheel_set. Untuk mobil cAnda akan menggunakanc.wheel_set.all()

Sementara jawaban batu bergulir itu baik, langsung dan fungsional, saya pikir ada dua hal yang tidak dipecahkan.

1. Jika OP ingin memberlakukan nomor telepon tidak boleh milik Bung dan Bisnis
2. Perasaan sedih yang tak terhindarkan sebagai akibat dari mendefinisikan hubungan pada model PhoneNumber dan bukan pada model Bung / Bisnis. Ketika makhluk luar angkasa tambahan datang ke Bumi, dan kami ingin menambahkan model Alien, kami perlu memodifikasi PhoneNumber (dengan asumsi ET memiliki nomor telepon) alih-alih hanya menambahkan bidang "nomor telepon" ke model Alien.

Memperkenalkan kerangka jenis konten , yang memperlihatkan beberapa objek yang memungkinkan kita membuat "kunci asing generik" pada model PhoneNumber. Kemudian, kita dapat mendefinisikan hubungan terbalik pada Bung dan Bisnis

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)

Lihat dokumen untuk detailnya, dan mungkin lihat artikel ini untuk tutorial cepat.

Juga, berikut adalah artikel yang menentang penggunaan FK Generik.

Jika model "banyak" tidak membenarkan pembuatan model per-se (tidak terjadi di sini, tetapi mungkin menguntungkan orang lain), alternatif lain akan bergantung pada tipe data PostgreSQL tertentu, melalui paket Django Contrib

Postgres dapat menangani tipe data Array atau JSON , dan ini mungkin merupakan solusi yang bagus untuk menangani One-To-Many ketika banyak- hanya dapat diikat ke satu entitas dari satu .

Postgres memungkinkan Anda untuk mengakses elemen tunggal dari array, yang berarti bahwa kueri bisa sangat cepat, dan menghindari overhead tingkat aplikasi. Dan tentu saja, Django mengimplementasikan API keren untuk meningkatkan fitur ini.

Ini jelas memiliki kelemahan karena tidak portabel untuk backend database orang lain, tapi saya pikir itu masih layak disebut.

Semoga ini bisa membantu beberapa orang mencari ide.

Pertama-tama, kami melakukan tur:

01) hubungan satu-ke-banyak:

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 tidak menyediakan hubungan OneToMany. Jadi kita tidak bisa menggunakan metode teratas di Django. Tetapi kita perlu mengkonversi dalam model relasional. Jadi apa yang bisa kita lakukan? Dalam situasi ini kita perlu mengubah model relasional menjadi model relasional terbalik.

Sini:

model relasional = OneToMany

Jadi, balikkan model relasional = ManyToOne

NB: Django mendukung hubungan ManyToOne & di Django ManyToOne diwakili oleh ForeignKey.

02) hubungan banyak-ke-satu:

SOLVE:

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

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

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

NB: PIKIR SIMPLY !!