Django Model Fields

What is a Django Model?

A Django model is the single, definitive source of information about your data. It contains the essential fields and behaviors of the data you’re storing. Each model maps to a single database table.

This concept is the heart of the ORM. You work with Python objects, and Django takes care of the database commands. Given your background in Python classes and SQL, you can think of a model as a Pythonic blueprint for a database table.

To get a solid grasp of this concept, let's start with a foundational reading from the Mozilla Developer Network (MDN).

Defining Fields: The Building Blocks of a Model

As you just read, models are defined in an app's models.py file. A model is composed of fields, where each field represents a column in the database table and tells Django what type of data to store.

Django comes with a wide variety of built-in field types. Let's explore the most common ones you'll use to build your models. The following video provides a rapid tour of many of these fields and their options. We will refer back to specific parts of it as we discuss each field type.

Text Fields: CharField and TextField

• models.CharField: Used for short-to-medium length strings.
  • It has one required argument: max_length. This is enforced at both the database level and in Django's validation.
• models.TextField: Used for large amounts of text. It's like a CharField but without a max_length requirement.

Common Options for Text Fields:

• help_text: Displays additional helpful text in forms (like in the Django admin).
• verbose_name: A human-readable name for the field. If not provided, Django creates it from the field's variable name.
• unique=True: Ensures that every value in this column is unique across all rows in the table.

Watch the video from 01:52 to 02:26 to see CharField in action with max_length, unique, and help_text.

Numeric Fields: IntegerField, DecimalField, and more

• models.IntegerField: Stores integer (whole number) values. Django also provides PositiveIntegerField, SmallIntegerField, etc., for more specific needs, which can optimize database storage and provide automatic validation.
• models.DecimalField: Used for storing fixed-precision decimal numbers, which is crucial for financial data to avoid floating-point rounding errors.
  • Required arguments: max_digits (total number of digits allowed) and decimal_places (number of digits after the decimal point).

You can see DecimalField demonstrated from 03:07 to 04:02 in the video, and the various integer fields are discussed from 04:55 to 05:45.

Date and Time Fields: DateField and DateTimeField

• models.DateField: Stores a date (YYYY-MM-DD).
• models.DateTimeField: Stores a date and time.

These fields have two very useful options for handling timestamps:

• auto_now_add=True: Automatically sets the field to the current date/time only when the object is first created. Perfect for a created_at timestamp.
• auto_now=True: Automatically updates the field to the current date/time every time the object is saved. Perfect for a last_updated timestamp.

The Pyplane video covers auto_now and auto_now_add from 08:00 to 09:20. It's important to note that when you use either of these options, the field becomes non-editable by default.

Other Common Field Types

• models.BooleanField: A true/false field. You can set a default value, like default=False.
• models.EmailField: A CharField that also checks if the value is a valid email address.
• models.UUIDField: Stores a universally unique identifier (UUID). Useful for primary keys if you don't want to use the default auto-incrementing integers.

Critical Field Options: null vs. blank

Two of the most important and often confused field options are null and blank.

• null=True: This is purely database-related. It means the database is allowed to store a NULL value for this field. For string-based fields like CharField and TextField, you should avoid null=True because Django's convention is to store empty strings ('') instead of NULL.
• blank=True: This is validation-related. It means the field is allowed to be empty in forms (e.g., the Django admin). The field is no longer required.

The rule of thumb is:

• For string-based fields (CharField, TextField), use blank=True.
• For non-string fields (IntegerField, DateField, ForeignKey), you often use null=True and blank=True together if the field is optional.

The Pyplane video has an outstanding, practical demonstration of this concept.

class Profile(models.Model):
    user = # ... (we'll cover this relationship in the next lesson)
    # How would you define bio and birth_date here?

class Profile(models.Model):
    user = # ...
    bio = models.TextField(blank=True) # A text field can be an empty string, so no null=True needed.
    birth_date = models.DateField(null=True, blank=True) # For non-string fields, we need both.

Putting It All Together: A Practical Example

Let's combine what we've learned to create a simple Post model for a blog application. This model will use several of the field types we've discussed.

Create a new app (e.g., python manage.py startapp blog) and open blog/models.py.

# blog/models.py
from django.db import models
from django.utils import timezone

class Post(models.Model):
    """
    Represents a single blog post.
    """
    # Choices for the status field
    STATUS_CHOICES = (
        ('draft', 'Draft'),
        ('published', 'Published'),
    )

    title = models.CharField(max_length=250, unique=True)
    content = models.TextField(blank=True)
    
    # auto_now_add=True sets the creation timestamp
    created_at = models.DateTimeField(auto_now_add=True)
    # auto_now=True updates the timestamp on every save
    updated_at = models.DateTimeField(auto_now=True)
    
    # A CharField with a dropdown menu of choices
    status = models.CharField(max_length=10, choices=STATUS_CHOICES, default='draft')
    
    is_featured = models.BooleanField(default=False)

    def __str__(self):
        """A string representation of the model."""
        return self.title

This example demonstrates:

• CharField with unique=True.
• TextField with blank=True.
• DateTimeField with auto_now_add and auto_now.
• CharField with a choices parameter to create a dropdown selector.
• BooleanField with a default value.
• The __str__ method, which provides a human-readable name for an object instance—essential for the Django admin and debugging.

Conclusion

In this lesson, you took a major step into the backend world of Django. You learned that models are Python classes that define your data's structure and that the ORM uses these models to manage all database interactions for you.

Key Takeaways:

• Models are Python classes that inherit from django.db.models.Model and map to database tables.
• Fields like CharField, IntegerField, and DateField define the columns of your database table and the type of data they store.
• Fields take arguments like max_length, default, and unique to further constrain the data.
• blank=True makes a field optional in forms (validation-related).
• null=True allows a database column to store NULL values (database-related).
• Timestamps can be automated with auto_now_add=True (on creation) and auto_now=True (on update).

We've laid the groundwork for defining individual tables. However, the real power of a database lies in the relationships between tables. In our next lesson, we will explore exactly that, learning how to connect our models using ForeignKey, ManyToManyField, and OneToOneField.