Django Models

Introduction to Django Models

In Django, models are Python classes that define the structure of your database tables. They map directly to your database schema and enable you to perform CRUD operations in a clean and intuitive way. This guide will walk you through creating, customizing, and querying Django models effectively.

Why Use Django Models?

Django’s models save you from writing raw SQL queries. With models, you get automatic schema generation, data validation, and a powerful query interface. The Django ORM (Object-Relational Mapper) translates your Python code into database operations.

Defining a Model

Models are declared in the `models.py` file of your Django app. For example, let’s define a `Book` model:

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)
    published_date = models.DateField()
    isbn = models.CharField(max_length=13, unique=True)

    def __str__(self):
        return f"{self.title} by {self.author}"

Common Field Types

• CharField: Fixed-length string field with `max_length`.
• TextField: Large text field suitable for articles or descriptions.
• DateField / DateTimeField: Stores dates and times.
• IntegerField, FloatField, DecimalField: Numeric fields for various data types.
• BooleanField: True/False field.
• ForeignKey / ManyToManyField: Define relationships between models.

Model Relationships

You can establish relationships between models for structured data. An example:

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

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

Here, each book is linked to an author. `on_delete=models.CASCADE` ensures that deleting an author also removes their books.

Applying Migrations

After defining or updating models, Django migrations synchronize the database schema. Use:

python manage.py makemigrations
python manage.py migrate

`makemigrations` creates migration files, and `migrate` applies them to the database.

Querying the Database

Django ORM lets you retrieve data using intuitive methods. Examples:

from myapp.models import Book

# Retrieve all books
books = Book.objects.all()

# Filter by author
books_by_author = Book.objects.filter(author__name="Jane Doe")

# Get a single book by ISBN
book = Book.objects.get(isbn="1234567890123")

# Create a new book instance and save it
new_book = Book(
    title="New Adventures",
    author=some_author,
    published_date="2024-01-01",
    isbn="9876543210987"
)
new_book.save()

Model Customization

You can customize model behavior through inner `Meta` class and custom methods:

class Book(models.Model):
    # fields...

    class Meta:
        ordering = ['-published_date']
        verbose_name = "Book Entry"

    def get_author_name(self):
        return self.author.name.upper()

Admin Integration

Registering models in the Django admin site allows you to manage data via a user-friendly interface. Add the following in `admin.py`:

from django.contrib import admin
from .models import Book

admin.site.register(Book)

Conclusion

Django models are the foundation of any Django application. They define your data structure, simplify database operations, and integrate seamlessly with the Django admin site. By mastering models and the ORM, you create scalable and maintainable data-layer logic for your web apps.