Bài 07: Django Models Basics

Django ORM và Models

ORM Là Gì?

ORM (Object-Relational Mapping) là technique map giữa database tables và Python objects. Django ORM cho phép làm việc với database bằng Python code thay vì SQL.

Without ORM (Raw SQL):

# Raw SQL - Complex and error-proneimport sqlite3 conn = sqlite3.connect('db.sqlite3')cursor = conn.cursor() # Create tablecursor.execute('''    CREATE TABLE posts (        id INTEGER PRIMARY KEY,        title VARCHAR(200),        content TEXT,        created TIMESTAMP    )''') # Insert datacursor.execute(    "INSERT INTO posts (title, content, created) VALUES (?, ?, ?)",    ('My Post', 'Content here', '2023-10-28')) # Query datacursor.execute("SELECT * FROM posts WHERE title LIKE '%Django%'")posts = cursor.fetchall() conn.commit()conn.close()

With Django ORM:

# Django ORM - Clean and Pythonicfrom django.db import modelsfrom django.utils import timezone # Define modelclass Post(models.Model):    title = models.CharField(max_length=200)    content = models.TextField()    created = models.DateTimeField(default=timezone.now) # Insert dataPost.objects.create(    title='My Post',    content='Content here') # Query dataposts = Post.objects.filter(title__icontains='Django')

Benefits of Django ORM:

# ✅ Database agnostic (SQLite, PostgreSQL, MySQL)# ✅ Automatic SQL generation# ✅ Protection against SQL injection# ✅ Pythonic syntax# ✅ Built-in validation# ✅ Relationships handling# ✅ Migrations support

Models Là Gì?

Model là Python class đại diện cho database table. Mỗi model attribute tương ứng với một table column.

# Python Modelclass Post(models.Model):    title = models.CharField(max_length=200)    content = models.TextField()    published = models.BooleanField(default=False)    created = models.DateTimeField(auto_now_add=True) # Database Table: blog_post# ┌────┬─────────────────────┬──────────┬───────────┬─────────────────────┐# │ id │ title               │ content  │ published │ created             │# ├────┼─────────────────────┼──────────┼───────────┼─────────────────────┤# │ 1  │ Django Tutorial     │ ...      │ True      │ 2023-10-28 10:00:00 │# │ 2  │ Python Basics       │ ...      │ False     │ 2023-10-28 11:00:00 │# └────┴─────────────────────┴──────────┴───────────┴─────────────────────┘

Defining Models

Basic Model Structure

# blog/models.pyfrom django.db import modelsfrom django.utils import timezonefrom django.contrib.auth.models import User class Post(models.Model):    """Blog post model."""        # Fields    title = models.CharField(max_length=200)    slug = models.SlugField(unique=True)    author = models.ForeignKey(User, on_delete=models.CASCADE)    content = models.TextField()    excerpt = models.TextField(max_length=500, blank=True)    published = models.BooleanField(default=False)    created = models.DateTimeField(auto_now_add=True)    updated = models.DateTimeField(auto_now=True)        class Meta:        ordering = ['-created']        verbose_name = 'Post'        verbose_name_plural = 'Posts'        def __str__(self):        return self.title        def get_absolute_url(self):        from django.urls import reverse        return reverse('blog:post_detail', kwargs={'slug': self.slug})

Model Components

class Post(models.Model):    # 1. Fields - Database columns    title = models.CharField(max_length=200)        # 2. Meta class - Model metadata    class Meta:        ordering = ['-created']        # 3. __str__ method - String representation    def __str__(self):        return self.title        # 4. Custom methods - Business logic    def is_recent(self):        return self.created >= timezone.now() - timezone.timedelta(days=7)        # 5. Properties - Computed fields    @property    def word_count(self):        return len(self.content.split())

Model Fields

String Fields

from django.db import models class Article(models.Model):    # CharField - Short text (required: max_length)    title = models.CharField(max_length=200)        # TextField - Long text (no max_length needed)    content = models.TextField()        # EmailField - Email validation    email = models.EmailField()        # URLField - URL validation    website = models.URLField(blank=True)        # SlugField - URL-friendly string    slug = models.SlugField(unique=True)        # TextField with max_length    excerpt = models.TextField(max_length=500)

CharField vs TextField:

# CharField - For short text# - Rendered as <input type="text"> in forms# - Requires max_length# - Indexed by default# - Examples: title, name, email title = models.CharField(max_length=200) # TextField - For long text# - Rendered as <textarea> in forms# - No max_length needed# - Not indexed by default# - Examples: content, description, bio content = models.TextField()

Numeric Fields

class Product(models.Model):    # IntegerField - Whole numbers    quantity = models.IntegerField(default=0)        # PositiveIntegerField - Only positive numbers    views = models.PositiveIntegerField(default=0)        # SmallIntegerField - Small integers (-32768 to 32767)    rating = models.SmallIntegerField(default=0)        # BigIntegerField - Large integers    total_sales = models.BigIntegerField(default=0)        # DecimalField - Precise decimal numbers    # Required: max_digits, decimal_places    price = models.DecimalField(max_digits=10, decimal_places=2)    # Examples: 99.99, 1234.56, 999999.99        # FloatField - Floating point numbers    weight = models.FloatField(default=0.0)

DecimalField vs FloatField:

# DecimalField - Use for money/precise values# - Exact precision# - No rounding errors# - Required: max_digits, decimal_placesprice = models.DecimalField(max_digits=10, decimal_places=2)# max_digits=10: Total digits (including decimals)# decimal_places=2: Digits after decimal point# Examples: 99.99, 1234.56, 12345678.99 # FloatField - Use for measurements/approximate values# - Faster# - Potential rounding errors# - For scientific calculationsweight = models.FloatField()

Boolean Fields

class Post(models.Model):    # BooleanField - True/False    published = models.BooleanField(default=False)    featured = models.BooleanField(default=False)        # NullBooleanField - True/False/None (deprecated in Django 4.0)    # Use BooleanField(null=True) instead    approved = models.BooleanField(null=True, blank=True)

Date and Time Fields

from django.utils import timezone class Event(models.Model):    # DateField - Date only (YYYY-MM-DD)    event_date = models.DateField()        # TimeField - Time only (HH:MM:SS)    event_time = models.TimeField()        # DateTimeField - Date and time    start_datetime = models.DateTimeField()        # auto_now_add - Set once on creation    created = models.DateTimeField(auto_now_add=True)        # auto_now - Update on every save    updated = models.DateTimeField(auto_now=True)        # default - Default value    published_at = models.DateTimeField(default=timezone.now)

auto_now vs auto_now_add vs default:

# auto_now_add - Set ONCE when object is createdcreated = models.DateTimeField(auto_now_add=True)# Can't be changed manually# Use for: created_at, registered_at # auto_now - Update EVERY time object is savedupdated = models.DateTimeField(auto_now=True)# Can't be changed manually# Use for: updated_at, modified_at # default - Set if no value provided, but can be changedpublished = models.DateTimeField(default=timezone.now)# Can be changed manually# Use for: published_at, scheduled_at

File Fields

class Document(models.Model):    # FileField - Any file    file = models.FileField(upload_to='documents/')        # ImageField - Image files only (requires Pillow)    # pip install Pillow    image = models.ImageField(upload_to='images/')        # upload_to with function    def user_directory_path(instance, filename):        # File will be uploaded to MEDIA_ROOT/user_<id>/<filename>        return f'user_{instance.user.id}/{filename}'        avatar = models.ImageField(upload_to=user_directory_path)        # upload_to with date    photo = models.ImageField(upload_to='photos/%Y/%m/%d/')    # Uploaded on 2023-10-28 → photos/2023/10/28/photo.jpg

FileField Example:

# models.pyclass Profile(models.Model):    user = models.OneToOneField(User, on_delete=models.CASCADE)    avatar = models.ImageField(upload_to='avatars/', blank=True)    resume = models.FileField(upload_to='resumes/', blank=True) # views.pydef upload_avatar(request):    if request.method == 'POST' and request.FILES.get('avatar'):        profile = request.user.profile        profile.avatar = request.FILES['avatar']        profile.save() # template{% if profile.avatar %}    <img src="{{ profile.avatar.url }}" alt="Avatar">{% endif %} # Accessing file propertiesprofile.avatar.name      # 'avatars/user_avatar.jpg'profile.avatar.size      # 102400 (bytes)profile.avatar.url       # '/media/avatars/user_avatar.jpg'

Choice Fields

class Article(models.Model):    # Define choices    STATUS_CHOICES = [        ('draft', 'Draft'),        ('published', 'Published'),        ('archived', 'Archived'),    ]        status = models.CharField(        max_length=20,        choices=STATUS_CHOICES,        default='draft'    )        # Using TextChoices (Django 3.0+)    class Status(models.TextChoices):        DRAFT = 'draft', 'Draft'        PUBLISHED = 'published', 'Published'        ARCHIVED = 'archived', 'Archived'        status = models.CharField(        max_length=20,        choices=Status.choices,        default=Status.DRAFT    )        # Using IntegerChoices    class Priority(models.IntegerChoices):        LOW = 1, 'Low'        MEDIUM = 2, 'Medium'        HIGH = 3, 'High'        priority = models.IntegerField(        choices=Priority.choices,        default=Priority.MEDIUM    ) # Usage in codearticle = Article.objects.create(    title='My Article',    status=Article.Status.PUBLISHED,    priority=Article.Priority.HIGH) # Get display valuearticle.status  # 'published'article.get_status_display()  # 'Published' # Check valueif article.status == Article.Status.PUBLISHED:    print("Article is published")

Other Fields

class Misc(models.Model):    # UUIDField - Universally Unique Identifier    import uuid    id = models.UUIDField(        primary_key=True,        default=uuid.uuid4,        editable=False    )        # JSONField - Store JSON data (Django 3.1+)    metadata = models.JSONField(default=dict, blank=True)    # Store: {'key': 'value', 'tags': ['python', 'django']}        # BinaryField - Store raw binary data    binary_data = models.BinaryField()        # IPAddressField (deprecated, use GenericIPAddressField)    ip_address = models.GenericIPAddressField()

Field Options

Common Field Options

class Post(models.Model):    # null - Database level (can be NULL in database)    # blank - Validation level (can be empty in forms)        # Required field (default)    title = models.CharField(max_length=200)    # null=False, blank=False        # Optional field    subtitle = models.CharField(max_length=200, blank=True, null=True)    # null=True: Database allows NULL    # blank=True: Forms allow empty value        # TextField blank but not null (stores empty string '')    excerpt = models.TextField(blank=True)    # null=False (default), blank=True    # Stores '' instead of NULL        # default - Default value    published = models.BooleanField(default=False)    views = models.IntegerField(default=0)        # unique - Must be unique    slug = models.SlugField(unique=True)    email = models.EmailField(unique=True)        # db_index - Add database index (faster queries)    username = models.CharField(max_length=50, db_index=True)        # editable - Can be edited in admin/forms    created = models.DateTimeField(auto_now_add=True, editable=False)        # choices - Predefined choices    status = models.CharField(max_length=20, choices=STATUS_CHOICES)        # help_text - Help text for forms    bio = models.TextField(        blank=True,        help_text='Tell us about yourself'    )        # verbose_name - Human-readable name    published_date = models.DateTimeField(        verbose_name='publication date'    )

null vs blank:

# null - Database level# - Can database column contain NULL?# - For database integrity # blank - Validation level  # - Can form field be empty?# - For form validation # Examples: # 1. CharField/TextField - Use blank=True (not null=True)description = models.TextField(blank=True)# Stores empty string '' instead of NULL# Reason: Django convention - one way to represent "no data" # 2. IntegerField/DateField - Use null=True and blank=Trueage = models.IntegerField(null=True, blank=True)# Can't store empty string in integer field# Must use NULL to represent "no data" # 3. BooleanField - Don't use null=Truepublished = models.BooleanField(default=False)# Use default instead# If need three states (True/False/Unknown):approved = models.BooleanField(null=True, blank=True) # 4. ForeignKey - Usually null=True, blank=Truecategory = models.ForeignKey(    Category,    on_delete=models.SET_NULL,    null=True,    blank=True)

Model Meta Options

class Post(models.Model):    title = models.CharField(max_length=200)    created = models.DateTimeField(auto_now_add=True)        class Meta:        # Table name        db_table = 'blog_posts'                # Ordering (default order for queries)        ordering = ['-created']  # Descending        # ordering = ['created']  # Ascending        # ordering = ['-created', 'title']  # Multiple fields                # Verbose names (for admin)        verbose_name = 'Blog Post'        verbose_name_plural = 'Blog Posts'                # Unique together (composite unique constraint)        unique_together = [['user', 'title']]        # Same user can't have posts with same title                # Indexes        indexes = [            models.Index(fields=['title']),            models.Index(fields=['created', 'published']),        ]                # Constraints (Django 2.2+)        constraints = [            models.CheckConstraint(                check=models.Q(price__gte=0),                name='price_gte_0'            ),        ]                # Permissions        permissions = [            ('can_publish', 'Can publish posts'),            ('can_feature', 'Can feature posts'),        ]                # Abstract model (no database table)        abstract = False                # Proxy model (same table, different Python behavior)        proxy = False

Model Methods

str Method

class Post(models.Model):    title = models.CharField(max_length=200)        def __str__(self):        """String representation of object."""        return self.title # Usagepost = Post.objects.get(id=1)print(post)  # Prints: "My Post Title" # In admin list# Without __str__: Post object (1)# With __str__: My Post Title

get_absolute_url

class Post(models.Model):    slug = models.SlugField(unique=True)        def get_absolute_url(self):        """Return canonical URL for object."""        from django.urls import reverse        return reverse('blog:post_detail', kwargs={'slug': self.slug}) # Usagepost = Post.objects.get(slug='django-tutorial')url = post.get_absolute_url()  # '/blog/django-tutorial/' # In templates<a href="{{ post.get_absolute_url }}">{{ post.title }}</a> # In viewsreturn redirect(post.get_absolute_url())

Custom Methods

from django.utils import timezonefrom datetime import timedelta class Post(models.Model):    title = models.CharField(max_length=200)    content = models.TextField()    created = models.DateTimeField(auto_now_add=True)    views = models.IntegerField(default=0)        def is_recent(self):        """Check if post was created in last 7 days."""        return self.created >= timezone.now() - timedelta(days=7)        def increment_views(self):        """Increment view count."""        self.views += 1        self.save(update_fields=['views'])        def get_excerpt(self, length=100):        """Get excerpt from content."""        if len(self.content) <= length:            return self.content        return self.content[:length] + '...'        def word_count(self):        """Count words in content."""        return len(self.content.split()) # Usagepost = Post.objects.get(id=1) if post.is_recent():    print("This is a recent post") post.increment_views() excerpt = post.get_excerpt(50)words = post.word_count()

Properties

class Post(models.Model):    title = models.CharField(max_length=200)    content = models.TextField()    created = models.DateTimeField(auto_now_add=True)        @property    def word_count(self):        """Return word count (computed field)."""        return len(self.content.split())        @property    def reading_time(self):        """Estimated reading time in minutes."""        words = self.word_count        return max(1, words // 200)  # 200 words per minute        @property    def is_new(self):        """Check if post is less than 24 hours old."""        age = timezone.now() - self.created        return age.days < 1 # Usage (like attributes, not methods)post = Post.objects.get(id=1) print(post.word_count)      # 500 (not post.word_count())print(post.reading_time)    # 3 minutesif post.is_new:    print("New post!")

Bài Tập

Bài 1: Basic Model

Task: Tạo Blog Post model:

# blog/models.py# Create Post model with:# - title (CharField)# - slug (SlugField, unique)# - content (TextField)# - published (BooleanField)# - created (DateTimeField)# - updated (DateTimeField) # Add:# - __str__ method# - get_absolute_url method# - Meta class (ordering, verbose_name)

Bài 2: E-commerce Models

Task: Tạo Product model:

# shop/models.pyclass Product(models.Model):    # Fields:    # - name    # - slug    # - description    # - price (DecimalField)    # - stock (PositiveIntegerField)    # - image (ImageField)    # - available (BooleanField)    # - created, updated        # Methods:    # - is_in_stock()    # - get_discount_price()

Bài 3: Custom Methods

Task: Add custom methods to Post model:

# Methods to implement:# 1. get_excerpt(length=100)# 2. word_count() # 3. reading_time()# 4. is_recent() - created in last 7 days# 5. get_related_posts(count=5)

Bài 4: Choice Fields

Task: Add status field với choices:

class Post(models.Model):    class Status(models.TextChoices):        DRAFT = 'draft', 'Draft'        PUBLISHED = 'published', 'Published'        ARCHIVED = 'archived', 'Archived'        status = models.CharField(        max_length=20,        choices=Status.choices,        default=Status.DRAFT    )        # Method to check if published    def is_published(self):        return self.status == self.Status.PUBLISHED

Tài Liệu Tham Khảo

Previous: Bài 06: Static Files | Next: Bài 08: Database Migrations

#fields

Advanced Model Fields và Custom Fields - Phần 1

Django Models Basics