One-to-one relationships

To define a one-to-one relationship, use OneToOneField.

In this example, a Place optionally can be a Restaurant:

  1. from django.db import models
  2. class Place(models.Model):
  3. name = models.CharField(max_length=50)
  4. address = models.CharField(max_length=80)
  5. def __str__(self):
  6. return f"{self.name} the place"
  7. class Restaurant(models.Model):
  8. place = models.OneToOneField(
  9. Place,
  10. on_delete=models.CASCADE,
  11. primary_key=True,
  12. )
  13. serves_hot_dogs = models.BooleanField(default=False)
  14. serves_pizza = models.BooleanField(default=False)
  15. def __str__(self):
  16. return "%s the restaurant" % self.place.name
  17. class Waiter(models.Model):
  18. restaurant = models.ForeignKey(Restaurant, on_delete=models.CASCADE)
  19. name = models.CharField(max_length=50)
  20. def __str__(self):
  21. return "%s the waiter at %s" % (self.name, self.restaurant)

What follows are examples of operations that can be performed using the Python API facilities.

Create a couple of Places:

  1. >>> p1 = Place(name="Demon Dogs", address="944 W. Fullerton")
  2. >>> p1.save()
  3. >>> p2 = Place(name="Ace Hardware", address="1013 N. Ashland")
  4. >>> p2.save()

Create a Restaurant. Pass the “parent” object as this object’s primary key:

  1. >>> r = Restaurant(place=p1, serves_hot_dogs=True, serves_pizza=False)
  2. >>> r.save()

A Restaurant can access its place:

  1. >>> r.place
  2. <Place: Demon Dogs the place>

A Place can access its restaurant, if available:

  1. >>> p1.restaurant
  2. <Restaurant: Demon Dogs the restaurant>

p2 doesn’t have an associated restaurant:

  1. >>> from django.core.exceptions import ObjectDoesNotExist
  2. >>> try:
  3. ... p2.restaurant
  4. ... except ObjectDoesNotExist:
  5. ... print("There is no restaurant here.")
  6. ...
  7. There is no restaurant here.

You can also use hasattr to avoid the need for exception catching:

  1. >>> hasattr(p2, "restaurant")
  2. False

Set the place using assignment notation. Because place is the primary key on Restaurant, the save will create a new restaurant:

  1. >>> r.place = p2
  2. >>> r.save()
  3. >>> p2.restaurant
  4. <Restaurant: Ace Hardware the restaurant>
  5. >>> r.place
  6. <Place: Ace Hardware the place>

Set the place back again, using assignment in the reverse direction:

  1. >>> p1.restaurant = r
  2. >>> p1.restaurant
  3. <Restaurant: Demon Dogs the restaurant>

Note that you must save an object before it can be assigned to a one-to-one relationship. For example, creating a Restaurant with unsaved Place raises ValueError:

  1. >>> p3 = Place(name="Demon Dogs", address="944 W. Fullerton")
  2. >>> Restaurant.objects.create(place=p3, serves_hot_dogs=True, serves_pizza=False)
  3. Traceback (most recent call last):
  4. ...
  5. ValueError: save() prohibited to prevent data loss due to unsaved related object 'place'.

Restaurant.objects.all() returns the Restaurants, not the Places. Note that there are two restaurants - Ace Hardware the Restaurant was created in the call to r.place = p2:

  1. >>> Restaurant.objects.all()
  2. <QuerySet [<Restaurant: Demon Dogs the restaurant>, <Restaurant: Ace Hardware the restaurant>]>

Place.objects.all() returns all Places, regardless of whether they have Restaurants:

  1. >>> Place.objects.order_by("name")
  2. <QuerySet [<Place: Ace Hardware the place>, <Place: Demon Dogs the place>]>

You can query the models using lookups across relationships:

  1. >>> Restaurant.objects.get(place=p1)
  2. <Restaurant: Demon Dogs the restaurant>
  3. >>> Restaurant.objects.get(place__pk=1)
  4. <Restaurant: Demon Dogs the restaurant>
  5. >>> Restaurant.objects.filter(place__name__startswith="Demon")
  6. <QuerySet [<Restaurant: Demon Dogs the restaurant>]>
  7. >>> Restaurant.objects.exclude(place__address__contains="Ashland")
  8. <QuerySet [<Restaurant: Demon Dogs the restaurant>]>

This also works in reverse:

  1. >>> Place.objects.get(pk=1)
  2. <Place: Demon Dogs the place>
  3. >>> Place.objects.get(restaurant__place=p1)
  4. <Place: Demon Dogs the place>
  5. >>> Place.objects.get(restaurant=r)
  6. <Place: Demon Dogs the place>
  7. >>> Place.objects.get(restaurant__place__name__startswith="Demon")
  8. <Place: Demon Dogs the place>

If you delete a place, its restaurant will be deleted (assuming that the OneToOneField was defined with on_delete set to CASCADE, which is the default):

  1. >>> p2.delete()
  2. (2, {'one_to_one.Restaurant': 1, 'one_to_one.Place': 1})
  3. >>> Restaurant.objects.all()
  4. <QuerySet [<Restaurant: Demon Dogs the restaurant>]>

Add a Waiter to the Restaurant:

  1. >>> w = r.waiter_set.create(name="Joe")
  2. >>> w
  3. <Waiter: Joe the waiter at Demon Dogs the restaurant>

Query the waiters:

  1. >>> Waiter.objects.filter(restaurant__place=p1)
  2. <QuerySet [<Waiter: Joe the waiter at Demon Dogs the restaurant>]>
  3. >>> Waiter.objects.filter(restaurant__place__name__startswith="Demon")
  4. <QuerySet [<Waiter: Joe the waiter at Demon Dogs the restaurant>]>