How to express a One-To-Many relationship in Django?

Question

I'm defining my Django models right now and I realized that there wasn't a OneToManyField in the model field types. I'm sure there's a way to do this, so I'm not sure what I'm missing. I essentially have something like this:

class Dude(models.Model):
    # 1 dude can have 0+ phone numbers
    numbers = models.OneToManyField('PhoneNumber')

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

In this case, each Dude can have multiple PhoneNumbers, but the relationship should be unidirectional, in that I don't need to know from the PhoneNumber which Dude owns it, per se, as I might have many different objects that own PhoneNumber instances, such as a Business for example:

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

What would I replace OneToManyField (which doesn't exist) with in the model to represent this kind of relationship? I'm coming from Hibernate/JPA where declaring a one-to-many relationship was as easy as:

@OneToMany
private List<PhoneNumber> phoneNumbers;

How can I express this in Django?

Bathysphere

Answer 1

To handle One-To-Many relationships in Django you need to use ForeignKey.

The documentation on ForeignKey is very comprehensive and should answer all the questions you have:

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

The current structure in your example allows each Dude to have one number, and each number to belong to multiple Dudes (same with Business).

---

If you want the reverse relationship, you would need to add two ForeignKey fields to your PhoneNumber model, one to Dude and one to Business. This would allow each number to belong to either one Dude or one Business, and have Dudes and Businesses able to own multiple PhoneNumbers. I think this might be what you're after:

class Business(models.Model):
    ...

class Dude(models.Model):
    ...

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

Quirinus

Could you give me an example given the problem above? I'm probably just missing it completely, but I've been reading the Django documentation for some time now and am still unclear as to how to create this kind of relationship. – Bathysphere

might want to make both of the ForeignKeys not required (blank=True, null=True), or add some sort of custom validation to make sure that there is at least one or the other. what about the case of a business having a generic number? or an unemployed dude? – Glucosuria

@Glucosuria good point about custom validation. but it seems kind of hacky to include both a foreignkey to dude and a foreignkey to business, and then do custom (external to the model definition) validation. seems like there has to be a cleaner way, but I can't figure it out either. – Decastere

In this situation it is appropriate to use the ContentTypes Framework which allows for generic relationships to different objects. However, using content types can get very complex very quickly, and if this is your only need, this simpler (if hacky) approach might be desirable. – Durman

One relevant thing to mention is the "related_name" argument to ForeignKey. So in the PhoneNumber class you'd have dude = models.ForeignKey(Dude, related_name='numbers') and then you can use some_dude_object.numbers.all() to get at all the related numbers (if you don't specify a "related_name" it'll default to "number_set"). – Staphyloplasty

Is it possible to modify this so that the number can belong to either a Business or a Dude, but not both at the same time? I am also wondering if it is easy to implement a switch of the number from Business to Dude and vice versa. – Afflux

@markshep, something like item.comments.all() works from python code BUT when I do {{ object.comments.all() }} in templates it says Could not parse the remainder: '()' from 'object.comments.all()' any extra config is required? – Zawde

Wow, 10 years later and this answer is still helpful. Thank you! As an extra note, I battled to get these relationships displaying in my templates but found that you can't call functions inside templates e.g. model_set.count(). Need to do that in the view then pass it to the template. – Bushranger

Answer 2

In Django, a one-to-many relationship is called ForeignKey. It only works in one direction, however, so rather than having a number attribute of class Dude you will need

class Dude(models.Model):
    ...

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

Many models can have a ForeignKey to one other model, so it would be valid to have a second attribute of PhoneNumber such that

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

You can access the PhoneNumbers for a Dude object d with d.phonenumber_set.objects.all(), and then do similarly for a Business object.

Carduaceous

I was under the assumption that ForeignKey meant "one-to-one." Using your above example, I should have a Dude that has many PhoneNumbers right? – Bathysphere

I edited my answer to reflect this. Yes. ForeignKey is only one-to-one if you specify ForeignKey(Dude, unique=True), so with the above code you will get a Dude with multiple PhoneNumbers. – Carduaceous

@rolling stone- thank you, I was adding that after realizing my mistake as you commented. Unique=True doesn't work exactly like OneToOneField, I meant to explain that ForeignKey only uses a one-to-one relationship if you specify Unique=True. – Carduaceous

You're right, that was a confusing way to clarify. I intended to modify rather than rewrite the models in the original question, but it makes more sense to show just the more useful answer. Fixed. – Carduaceous

+1 for doing it from the PhoneNumber. Now it's starting to make sense. ForeignKey is essentially many-to-one, so you need to do it backwards to get a one-to-many :) – Bathysphere

@rolling stone, sure if you have $50 ;) – Bathysphere

Can somebody explain the significance of the name of the field phonenumber_set? I don't see it defined anywhere. Is it the name of the model, in all lower case, appended with "_set" ? – Expellant

@JamesWierzba It is the related_name of the foreign key. There's some documentation on this in backwards-related objects that explains these defaults. – Undulation

Does it protect us against a Dude and a Business sharing the same phone number? – Cento

Note that the property name inside the class must have the same name as the foreign class and it's table name and key. So in my case, I tried something like mydude = models.ForeignKey(Dude) and django/python didn't complain about anything, yet it wouldn't return the objects, because it was trying to select the DB using the "primary key" of mydude_id instead of dude_id. Apparently the framework is not smart enough to get the DB primary key name from the Dude class. :( – Prophase

There is no one-to-many. That's why you used many-to-many instead. – Equalize

Answer 3

To be more clear - there's no OneToMany in Django, only ManyToOne - which is Foreignkey described above. You can describe OneToMany relation using Foreignkey but that is very inexpressively.

A good article about it: https://amir.rachum.com/blog/2013/06/15/a-case-for-a-onetomany-relationship-in-django/

Brownley

You can use ManyToManyField. – Sponge

How to use ManyToMany field? – Mansour

Answer 4

Django is smart enough. Actually we don't need to define oneToMany field. It will be automatically generated by Django for you. We only need to define a foreignKey in the related table. In other words, we only need to define ManyToOne relation by using 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)  

If we want to get the list of wheels of particular car, we will use Python's auto generated object wheel_set. For car c you will use c.wheel_set.all().

Plumbo

Can also modify auto-generated names with ForeignKey(related_name=...) – Downbeat

I'd vote this comment as the correct answer. What you need is to set related_name to your field definition. – Seeker

Answer 5

You can use either foreign key on many side of OneToMany relation (i.e. ManyToOne relation) or use ManyToMany (on any side) with unique constraint.

Botha

Answer 6

While rolling stone's answer is good, straightforward and functional, I think there are two things it does not solve.

1. If OP wanted to enforce a phone number cannot belong to both a Dude and a Business
2. The inescapable feeling of sadness as a result of defining the relationship on the PhoneNumber model and not on the Dude/Business models. When extra terrestrials come to Earth, and we want to add an Alien model, we need to modify the PhoneNumber (assuming the ETs have phone numbers) instead of simply adding a "phone_numbers" field to the Alien model.

Introduce the content types framework, which exposes some objects that allow us to create a "generic foreign key" on the PhoneNumber model. Then, we can define the reverse relationship on 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)

See the docs for details, and perhaps check out this article for a quick tutorial.

Also, here is an article that argues against the use of Generic FKs.

Faubert

Answer 7

First of all we take a tour:

01) one-to-many relationship:

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 doesn't provides any OneToMany relationship. So we can't use upper method in Django. But we need to convert in relational model. So what can we do? In this situation we need to convert relational model into reverse relational model.

Here:

relational model = OneToMany

So, reverse relational model = ManyToOne

NB: Django support ManyToOne relationship & in Django ManyToOne is represented by ForeignKey.

02) many-to-one relationship:

SOLVE:

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

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

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

NB: THINK SIMPLY!!

Locklin

Hello! How should I do in this case if I want the Business admin.py page to contain the phone number/s? – Kora

Answer 8

Actually, one-to-many relationship is very useful. I do something like this:

class Dude(models.Model):
    number = models.ManyToManyField(PhoneNumber)

    def save(self, *args, **kwargs):
        if Dude.objects.get(number=self.number):
            raise Exception("Dude, this number has been used.")
        return super(Dude, self).save(*args, **kwargs)

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

This will ensure the number only use once.

Alright

Answer 9

Whereas most answers here do pass in defining a relationship that allows you to define a OneToManyRelationship, they are actually in fact the definition of a ManyToManyRelationship.

Here is a more accurate implementation:

class Dude(models.Model):
    name = models.CharField(max_length=256, unique=True)

class PhoneNumber(models.Model):
    number = models.CharField(max_length=256, unique=True)

class DudePhoneNumbers(models.Model):
    dude = models.ForeignKey(Dude, related_name="phone_number_relations", on_delete=models.CASCADE)
    phone_number = models.OneToOneField(PhoneNumber, related_name="dude_relation", on_delete=models.CASCADE)

Nombril

Answer 10

If the "many" model does not justify the creation of a model per-se (not the case here, but it might benefits other people), another alternative would be to rely on specific PostgreSQL data types, via the Django Contrib package

Postgres can deal with Array or JSON data types, and this may be a nice workaround to handle One-To-Many when the many-ies can only be tied to a single entity of the one.

Postgres allows you to access single elements of the array, which means that queries can be really fast, and avoid application-level overheads. And of course, Django implements a cool API to leverage this feature.

It obviously has the disadvantage of not being portable to others database backend, but I thougt it still worth mentionning.

Hope it may help some people looking for ideas.

Nester

Answer 11

A one to many relationship implies that one model record can have many other model records associated with itself.

from django.db import models

class Menu(models.Model):
    name = models.CharField(max_length=30)

class Item(models.Model):
    menu = models.ForeignKey(Menu)
    name = models.CharField(max_length=30)
    description = models.CharField(max_length=100)

Feoffee