Django Models, One-To-Many

Today, I explored how Django’s models work and started learning about relationships between different models.

Django Models and ForeignKey Relationships

Django models are like character-sheet templates for the data in your app. They define how data is structured and how different pieces of information relate to each other (model relationships).

For example a model might look something like this:

class Book(models.Model): 
     Title
     Page_Count
     Age_Rating
     Marketing Excerpt
     Content
     Author
     Publisher

Today, primarily, I learned about how ForeignKey relationships help create relationships to other models. Specifically one-to-many relationships in databases.

• One-to-Many: This is a relationship that exists between database schemas to represent potential data_sets between models. Basically it’s like how one a Book can have only one Author (in most cases) but an Author can write many books. Or how a movie can have only one Director but a Director can direct many movies.

• ForeignKey: A ForeignKey is the method that is utilized from the Models library in Django which allows one model to be related to another in a One-To-Many relationship.

class Author(models.Model):
     first_name = models.CharField(max_length=50)
     last_name = models.CharField(max_length=50)


class Book(models.Model):
     title = models.CharField(max_length=100)
     author = models.ForeignKey(Author, on_delete=models.CASCADE, null=True)

Attributes:

• on_delete=models.CASCADE: ensures that if an author is deleted, all their related books are deleted as well.

• null=True: allows the author field to be empty in the database, which is useful if a book doesn’t have an assigned author.

• related_name: allows us to assign this attribute inside a one-to-many relationship to make a more readable set of objects withheld inside the “many” part of the relationship.

Understanding Reverse Relationships

One concept that took me a while to grasp was reverse relationships. These allow you to access related objects from the other side of a ForeignKey relationship. For example, I can get all the books an Author has written by using the reverse relationship.

It’s called a reverse relationship because only one model has the relationship defined in their model. The reverse model is the model it relates to.

class Book(models.Model):
     title = models.CharField(max_length=50)
     author = models.ForeignKey(Author, on_delete=models.CASCADE, null=True)


class Author(models.Model):
     first_name = “Brandon”
     last_name = “Sanderson”

Default Reverse Relationship:

By default, Django creates a model_set for the reverse lookup:

• In this example because there is a Book model, the set would be called book_set by default.

jkr = Author.objects.get(first_name="J.K.")
jkr.book_set.all() # Returns all books written by J.K. Rowling

• However, like I said earlier, we can use related name to make the code more readable.

class Book(models.Model):
     author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name='books')

• Now, I can access all books by J.K. Rowling using...

jkr.books.all()

Reflections from Today

Today’s biggest takeaway is the power of relationships in Django models. Specifically understanding ForeignKey and how to use related_name made it much easier to manage data between models. I need to continue to work on my understanding of how and when to use each relationship type and which is the best model to start the definition of the relationship. It feels great to start to know how to structure data in a way that scales as the app grows.