Model Inheritance in Django

Key Concepts

Model inheritance in Django allows you to create new models that inherit fields and behavior from existing models. This feature is useful for code reuse and organizing complex data structures. Key concepts include:

• Abstract Base Classes
• Multi-table Inheritance
• Proxy Models
• Custom Managers and Methods

1. Abstract Base Classes

Abstract base classes are used when you want to put some common information into a number of other models. You write your base class and put abstract=True in the Meta class. This model will then not be used to create any database table. Instead, when it is used as a base class for other models, its fields will be added to those of the child class.

from django.db import models

class CommonInfo(models.Model):
    name = models.CharField(max_length=100)
    age = models.PositiveIntegerField()

    class Meta:
        abstract = True

class Student(CommonInfo):
    home_group = models.CharField(max_length=5)
    

2. Multi-table Inheritance

Multi-table inheritance is used when each model in the hierarchy is a model all by itself. Each model corresponds to its own database table and can be queried and created individually. Django creates a OneToOneField for the relationship between the child and parent.

from django.db import models

class Place(models.Model):
    name = models.CharField(max_length=50)
    address = models.CharField(max_length=80)

class Restaurant(Place):
    serves_hot_dogs = models.BooleanField(default=False)
    serves_pizza = models.BooleanField(default=False)
    

3. Proxy Models

Proxy models are used when you want to change the Python-level behavior of a model, such as changing the default manager or adding new methods, without changing the model’s fields. Proxy models use the same database table as the original model.

from django.db import models

class Person(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)

class MyPerson(Person):
    class Meta:
        proxy = True

    def do_something(self):
        # Custom method
        pass
    

4. Custom Managers and Methods

Custom managers and methods can be added to models to extend their functionality. Managers are used to create custom queries, while methods can be used to add custom behavior to instances of the model.

from django.db import models

class BookManager(models.Manager):
    def small_books(self):
        return self.filter(pages__lte=100)

class Book(models.Model):
    title = models.CharField(max_length=100)
    pages = models.IntegerField()

    objects = BookManager()

    def is_short(self):
        return self.pages <= 100
    

Examples and Analogies

Think of abstract base classes as a blueprint for building houses. The blueprint contains common features like doors and windows, but it is not a house itself. When you build a house using this blueprint, it includes these common features.

Multi-table inheritance is like having a house and an apartment building. Both are buildings, but they are separate entities with their own characteristics. You can query and manage each building independently.

Proxy models are like a different view of the same house. You can change how you look at the house (e.g., from the front or back) without changing the house itself.

Custom managers and methods are like adding custom features to a house, such as a swimming pool or a security system. These features enhance the functionality of the house without changing its basic structure.

Conclusion

Understanding model inheritance in Django is essential for creating efficient and maintainable code. By using abstract base classes, multi-table inheritance, proxy models, and custom managers and methods, you can organize your data models effectively and extend their functionality as needed.