One-To-Many Relationship (ForeignKey)

Django Model Relations — 2

Before learning about this, you may want to take a look at one-to-one relationship.

One-To-One Relationship (OneToOneField)

Hire Me

One-To-Many Relationship

One record in a table can be associated with one or more records in another table.

- Car company can have one or more car model.
- Car model can only belong to one car company.

|--------|----------|
|CarModel|CarCompany|
|--------|----------|
| C180   | Mercedes |
| C200   | Mercedes |
| X1     | BMW      |
| X3     | BMW      |
| X5     | BMW      |
| X6     | BMW      |
|--------|----------|

$ from modelrelations.models import Car, CarModel
$ mercedes = Car.objects.create(name="Mercedes")
$ bmw = Car.objects.create(name="BMW")
$ Car.objects.all()
<QuerySet [
    <Car: Mercedes>, 
    <Car: BMW>
]>

When creating new car model:

$ c180 = CarModel.objects.create(name=”C180", car=mercedes)
$ c180.car
<Car: Mercedes>
$ c180.car.name
'Mercedes'

Create relation between Model and Car.

$ c200 = CarModel.objects.create(name=”C200")
$ c200.car = mercedes
$ c200.save()
$ c200.car.name
'Mercedes'

Create relation between Car and Model.

Django, by defaults gives you a default related_name which is the ModelName (in lowercase) followed by “_set”. In this case, It would be carmodel_set.

$ x1 = CarModel.objects.create(name=”X1")
$ x3 = CarModel.objects.create(name=”X3")
$ CarModel.objects.all()
<QuerySet [
    <CarModel: X1>, 
    <CarModel: X3>
]>

$ bmw.carmodel_set.add(x1, x3)
$ bmw.carmodel_set.all()
<QuerySet [
    <CarModel: X1>, 
    <CarModel: X3>
]>

Retrieve Records :

From car model to car:

$ c180.car
<Car: Mercedes>
$ c180.car.name
'Mercedes'

From car to car model:

$ mercedes.carmodel_set.all()
<QuerySet [
    <CarModel: C180>, 
    <CarModel: C200>
]>
$ mercedes.carmodel_set.first()
<CarModel: C180>
$ mercedes.carmodel_set.first().name
'C180'

Filter car models by car:

$ CarModel.objects.filter(car__name="Mercedes")
<QuerySet [
    <CarModel: C180>, 
    <CarModel: C200>
]>

Filter cars by car models:

$ Car.objects.filter(carmodel__name="C180")
<QuerySet [
    <Car: Mercedes>
]>

Delete Records :

When an object referenced by a ForeignKey is deleted, Django will emulate the behavior of the SQL constraint specified by the on_delete argument same as OneToOneField.

For more information about on_delete, you can check out our one-to-one article and django documentation :

One-To-One Relationship (OneToOneField)

Model field reference | Django documentation | Django

Reverse Relationship :

related_name will be the attribute of the related object that allows you to go ‘backwards’ to the model with the foreign key on it.

You can access the “CarModel” instances that are related to your “Car“ instance by going car_instance.models.all(). You can no longer use carmodel_set.

$ x5 = CarModel.objects.create(name=”X5")
$ x6 = CarModel.objects.create(name=”X6")
$ bmw.models.add(x5, x6)

related_query_name is for use in Django querysets. It allows you to filter on the reverse relationship of a foreign key related field.

$ Car.objects.filter(model__name="C180")
<QuerySet [
    <Car: Mercedes>
]>

When we try to assign the same model to one more than cars :

$ bmw.models.all()
<QuerySet [
    <CarModel: X1>, 
    <CarModel: X3>, 
    <CarModel: X5>, 
    <CarModel: X6>
]>
$ mercedes.models.add(x1)
$ mercedes.models.all()
<QuerySet [
    <CarModel: C180>, 
    <CarModel: C200>, 
    <CarModel: X1>
]>
$ bmw.models.all()
<QuerySet [
    <CarModel: X3>, 
    <CarModel: X5>, 
    <CarModel: X6>
]>
$ bmw.models.add(x1)
<QuerySet [
    <CarModel: X1>, 
    <CarModel: X3>, 
    <CarModel: X5>, 
    <CarModel: X6>
]>
$ mercedes.models.all()
<QuerySet [
    <CarModel: C180>, 
    <CarModel: C200>, 
]>

In the next part, we’ll learn many to many relations.

If you want to learn more about Django, do check out the documentation, django rest framework website and make sure to check out part of this series!