Django Models

What are models in Django?

In Django, models are Python classes that represent database tables. Each model class corresponds to a table in the database, and each attribute of the class corresponds to a field in that table. Django's Object-Relational Mapping (ORM) automatically translates these Python classes into SQL queries, allowing developers to interact with the database using Python code.

How do you define a model in Django?

To define a model in Django, you create a Python class that inherits from django.db.models.Model. Each class attribute represents a field in the database table, and Django automatically generates the necessary SQL for creating and managing the table.

Example of defining a model:

from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

In this example, the Post model represents a blog post with fields for the title, content, and the date it was created.

What are model fields in Django?

Model fields in Django represent the columns of the database table. Each field is an instance of a field class (such as CharField, IntegerField, or DateField), and each field corresponds to a specific data type in the database.

Example of model fields:

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=50)
    published_date = models.DateField()

In this example, the Book model contains fields for the title, author, and published date of a book.

What are some commonly used field types in Django models?

Django provides a variety of field types for use in models, each representing a specific type of data. Some commonly used field types include:

• CharField: Stores short text strings with a specified maximum length.
• TextField: Stores long text strings without a length limit.
• IntegerField: Stores integer values.
• BooleanField: Stores a True or False value.
• DateField: Stores date values.
• ForeignKey: Defines a one-to-many relationship to another model.
• ManyToManyField: Defines a many-to-many relationship to another model.

What is the purpose of the primary_key attribute in Django models?

The primary_key attribute is used to designate a field as the primary key for the model's database table. By default, Django automatically creates an id field as the primary key for each model, but you can override this by setting primary_key=True on another field.

Example of using primary_key:

class Student(models.Model):
    student_id = models.CharField(max_length=10, primary_key=True)
    name = models.CharField(max_length=100)

In this example, the student_id field is set as the primary key for the Student model, replacing the default id field.

How do you define a one-to-many relationship in Django models?

A one-to-many relationship in Django models is defined using the ForeignKey field. This establishes a relationship where multiple records in one model are related to a single record in another model.

Example of defining a one-to-many relationship:

from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)

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

In this example, each Book is associated with an Author, and multiple books can be related to the same author. The on_delete=models.CASCADE argument ensures that if an author is deleted, their related books are also deleted.

How do you define a many-to-many relationship in Django models?

A many-to-many relationship in Django models is defined using the ManyToManyField field. This allows multiple records in one model to be related to multiple records in another model.

Example of defining a many-to-many relationship:

from django.db import models

class Student(models.Model):
    name = models.CharField(max_length=100)

class Course(models.Model):
    title = models.CharField(max_length=100)
    students = models.ManyToManyField(Student)

In this example, multiple students can be enrolled in multiple courses, and each course can have many students. Django automatically creates an intermediary table to manage the many-to-many relationship.

What is the Meta class in Django models?

The Meta class in Django models is used to define metadata for the model, such as ordering, table name, unique constraints, and verbose names. This class provides additional options for how the model behaves and interacts with the database.

Example of using the Meta class:

class Product(models.Model):
    name = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=10, decimal_places=2)

    class Meta:
        ordering = ['name']
        verbose_name = 'Product Item'

In this example, the Meta class specifies that products should be ordered by their name, and the verbose name for the model is set to "Product Item".

How do you add a custom method to a Django model?

You can add custom methods to a Django model by defining a Python method within the model class. These methods can perform operations on the model's data or return specific information about the model instance.

Example of adding a custom method:

class Product(models.Model):
    name = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=10, decimal_places=2)

    def discounted_price(self, discount):
        return self.price * (1 - discount / 100)

In this example, the discounted_price method calculates the price of the product after applying a discount.

How do you create a custom manager in Django models?

Custom managers in Django models are used to modify or extend the behavior of the default model manager. You can create a custom manager by defining a class that inherits from models.Manager and adding methods to handle custom query logic.

Example of creating a custom manager:

class PublishedManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().filter(status='published')

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    status = models.CharField(max_length=10)

    objects = models.Manager()  # Default manager
    published = PublishedManager()  # Custom manager

In this example, the PublishedManager custom manager returns only posts that have a status of "published". You can access it using Post.published.all() to retrieve only published posts.

How do you use the save() method in Django models?

The save() method in Django models is used to save an instance of a model to the database. You can override this method to add custom logic before or after saving the object.

Example of overriding the save() method:

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()

    def save(self, *args, **kwargs):
        self.title = self.title.capitalize()  # Capitalize the title before saving
        super().save(*args, **kwargs)

In this example, the save() method is overridden to capitalize the title before saving the post to the database.

What is the purpose of the get_absolute_url() method in Django models?

The get_absolute_url() method in Django models is used to define the canonical URL for a model instance. It returns the URL to access a specific instance of the model and is often used in templates and views to link to individual model objects.

Example of defining the get_absolute_url() method:

from django.urls import reverse

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()

    def get_absolute_url(self):
        return reverse('post_detail', args=[str(self.id)])

In this example, the get_absolute_url() method returns the URL for the detail view of the post, using the post's ID as a parameter.

What is the ForeignKey field in Django models?

The ForeignKey field in Django models is used to define a one-to-many relationship between two models. It creates a link between two models, where each record in one model is related to multiple records in another model.

Example of using the ForeignKey field:

class Author(models.Model):
    name = models.CharField(max_length=100)

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

In this example, each book is associated with an author, and if an author is deleted, their related books are also deleted due to on_delete=models.CASCADE.

What is the ManyToManyField in Django models?

The ManyToManyField in Django models is used to define a many-to-many relationship between two models. This means that each record in one model can be related to multiple records in another model, and vice versa.

Example of using the ManyToManyField:

class Student(models.Model):
    name = models.CharField(max_length=100)

class Course(models.Model):
    title = models.CharField(max_length=100)
    students = models.ManyToManyField(Student)

In this example, students can enroll in multiple courses, and each course can have multiple students. Django automatically creates a join table to manage the relationship.

What is the on_delete parameter in Django models?

The on_delete parameter in Django models specifies what should happen when a related object (in a ForeignKey or OneToOneField) is deleted. It defines how the deletion of a related object affects the referencing model.

Common options for on_delete:

• CASCADE: Deletes related objects as well.
• PROTECT: Prevents the deletion of the related object.
• SET_NULL: Sets the related field to NULL.
• SET_DEFAULT: Sets the related field to its default value.

Example of using on_delete:

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

In this example, if an Author is deleted, their associated books are also deleted due to on_delete=models.CASCADE.