Bài 21: Model Relationships

Model Relationships Overview

Model Relationships định nghĩa mối quan hệ giữa các models trong database.

# Three types of relationships:# 1. ForeignKey - Many-to-One (nhiều posts thuộc một author)# 2. OneToOneField - One-to-One (một user có một profile)# 3. ManyToManyField - Many-to-Many (nhiều posts có nhiều tags) # Example:class Author(models.Model):    name = models.CharField(max_length=100) class Post(models.Model):    title = models.CharField(max_length=200)    author = models.ForeignKey(Author, on_delete=models.CASCADE)    # Many posts -> One author class Tag(models.Model):    name = models.CharField(max_length=50) class Post(models.Model):    tags = models.ManyToManyField(Tag)    # Many posts <-> Many tags

ForeignKey (Many-to-One)

Basic ForeignKey

from django.db import models class Author(models.Model):    name = models.CharField(max_length=100)    email = models.EmailField()        def __str__(self):        return self.name class Post(models.Model):    title = models.CharField(max_length=200)    content = models.TextField()    author = models.ForeignKey(Author, on_delete=models.CASCADE)    created = models.DateTimeField(auto_now_add=True)        def __str__(self):        return self.title # Usage:author = Author.objects.create(name='John Doe', email='john@example.com')post = Post.objects.create(    title='My Post',    content='Content here',    author=author  # Assign author) # Access author from postprint(post.author.name)  # John Doe # Access posts from author (reverse relationship)posts = author.post_set.all()  # QuerySet of posts

ForeignKey with related_name

class Category(models.Model):    name = models.CharField(max_length=100)    slug = models.SlugField(unique=True)        def __str__(self):        return self.name class Post(models.Model):    title = models.CharField(max_length=200)    category = models.ForeignKey(        Category,        on_delete=models.SET_NULL,        null=True,        related_name='posts'  # Custom reverse name    ) # Without related_name: category.post_set.all()# With related_name: category.posts.all() category = Category.objects.get(slug='tech')posts = category.posts.all()  # Cleaner!posts = category.posts.filter(published=True)count = category.posts.count()

ForeignKey on_delete Options

from django.db import models class Author(models.Model):    name = models.CharField(max_length=100) class Post(models.Model):    title = models.CharField(max_length=200)        # CASCADE - Delete posts when author deleted    author = models.ForeignKey(        Author,        on_delete=models.CASCADE    )        # PROTECT - Prevent author deletion if has posts    author = models.ForeignKey(        Author,        on_delete=models.PROTECT    )        # SET_NULL - Set to NULL when author deleted    author = models.ForeignKey(        Author,        on_delete=models.SET_NULL,        null=True    )        # SET_DEFAULT - Set to default when deleted    author = models.ForeignKey(        Author,        on_delete=models.SET_DEFAULT,        default=1    )        # SET() - Set to specific value/function    def get_default_author():        return Author.objects.get(username='deleted')        author = models.ForeignKey(        Author,        on_delete=models.SET(get_default_author)    )        # DO_NOTHING - Do nothing (database constraint may fail)    author = models.ForeignKey(        Author,        on_delete=models.DO_NOTHING    ) # Real-world example:class Post(models.Model):    author = models.ForeignKey(        'auth.User',        on_delete=models.CASCADE,  # Delete posts with user        related_name='posts'    )    category = models.ForeignKey(        'Category',        on_delete=models.SET_NULL,  # Keep posts, remove category        null=True,        blank=True,        related_name='posts'    )

Self-Referencing ForeignKey

class Comment(models.Model):    """Comment with nested replies"""    post = models.ForeignKey('Post', on_delete=models.CASCADE)    author = models.ForeignKey('auth.User', on_delete=models.CASCADE)    content = models.TextField()    parent = models.ForeignKey(        'self',  # Self-reference        on_delete=models.CASCADE,        null=True,        blank=True,        related_name='replies'    )    created = models.DateTimeField(auto_now_add=True) # Usage:# Top-level commentcomment = Comment.objects.create(    post=post,    author=user,    content='Great post!') # Reply to commentreply = Comment.objects.create(    post=post,    author=user,    content='Thank you!',    parent=comment  # Reply to first comment) # Get all replies to a commentreplies = comment.replies.all() # Get top-level comments (no parent)top_comments = Comment.objects.filter(post=post, parent=None) # Employee hierarchy example:class Employee(models.Model):    name = models.CharField(max_length=100)    manager = models.ForeignKey(        'self',        on_delete=models.SET_NULL,        null=True,        blank=True,        related_name='subordinates'    ) # Usage:ceo = Employee.objects.create(name='CEO')manager = Employee.objects.create(name='Manager', manager=ceo)employee = Employee.objects.create(name='Employee', manager=manager) # Get manager's subordinatesteam = manager.subordinates.all()

OneToOneField

Basic OneToOneField

from django.contrib.auth.models import User class UserProfile(models.Model):    """Extended user information"""    user = models.OneToOneField(        User,        on_delete=models.CASCADE,        related_name='profile'    )    bio = models.TextField(blank=True)    avatar = models.ImageField(upload_to='avatars/', blank=True)    website = models.URLField(blank=True)    birth_date = models.DateField(null=True, blank=True)        def __str__(self):        return f"{self.user.username}'s profile" # Usage:user = User.objects.create_user(username='john')profile = UserProfile.objects.create(    user=user,    bio='Python developer') # Access profile from userprint(user.profile.bio)  # Python developer # Access user from profileprint(profile.user.username)  # john

OneToOneField with Signals

from django.db.models.signals import post_savefrom django.dispatch import receiver class UserProfile(models.Model):    user = models.OneToOneField(User, on_delete=models.CASCADE)    bio = models.TextField(blank=True) @receiver(post_save, sender=User)def create_user_profile(sender, instance, created, **kwargs):    """Auto-create profile when user created"""    if created:        UserProfile.objects.create(user=instance) @receiver(post_save, sender=User)def save_user_profile(sender, instance, **kwargs):    """Save profile when user saved"""    instance.profile.save() # Now profile auto-created with user:user = User.objects.create_user(username='john')# user.profile exists automatically!

Multi-table Inheritance (OneToOne)

class Place(models.Model):    """Base place model"""    name = models.CharField(max_length=100)    address = models.CharField(max_length=200) class Restaurant(Place):    """Restaurant extends Place (implicit OneToOne)"""    cuisine = models.CharField(max_length=50)    rating = models.IntegerField() # Creates implicit OneToOneField# Equivalent to:class Restaurant(models.Model):    place = models.OneToOneField(Place, on_delete=models.CASCADE, parent_link=True)    cuisine = models.CharField(max_length=50)    rating = models.IntegerField() # Usage:restaurant = Restaurant.objects.create(    name='Pizza Palace',    address='123 Main St',    cuisine='Italian',    rating=5) # Access parent fieldsprint(restaurant.name)  # Pizza Palaceprint(restaurant.cuisine)  # Italian # Access child from parentplace = Place.objects.get(name='Pizza Palace')print(place.restaurant.cuisine)  # Italian

ManyToManyField

Basic ManyToManyField

class Tag(models.Model):    name = models.CharField(max_length=50, unique=True)    slug = models.SlugField(unique=True)        def __str__(self):        return self.name class Post(models.Model):    title = models.CharField(max_length=200)    tags = models.ManyToManyField(        Tag,        related_name='posts',        blank=True    ) # Usage - Adding tags:post = Post.objects.create(title='Django Tutorial')tag1 = Tag.objects.create(name='Django', slug='django')tag2 = Tag.objects.create(name='Python', slug='python') # Add tagspost.tags.add(tag1, tag2)post.tags.add(tag1.id, tag2.id)  # Or by ID # Get tagstags = post.tags.all() # Remove tagspost.tags.remove(tag1) # Clear all tagspost.tags.clear() # Set tags (replace all)post.tags.set([tag1, tag2]) # Reverse - posts with tagposts = tag1.posts.all()

ManyToMany Through Model

class Author(models.Model):    name = models.CharField(max_length=100) class Book(models.Model):    title = models.CharField(max_length=200)    authors = models.ManyToManyField(        Author,        through='BookAuthor',        related_name='books'    ) class BookAuthor(models.Model):    """Intermediate model with extra fields"""    book = models.ForeignKey(Book, on_delete=models.CASCADE)    author = models.ForeignKey(Author, on_delete=models.CASCADE)    role = models.CharField(        max_length=50,        choices=[            ('author', 'Author'),            ('co-author', 'Co-Author'),            ('editor', 'Editor'),        ]    )    contribution_date = models.DateField()        class Meta:        unique_together = [['book', 'author']] # Usage:book = Book.objects.create(title='Django Book')author1 = Author.objects.create(name='John')author2 = Author.objects.create(name='Jane') # Can't use add() with through model# Must create through model explicitly:BookAuthor.objects.create(    book=book,    author=author1,    role='author',    contribution_date='2024-01-01')BookAuthor.objects.create(    book=book,    author=author2,    role='co-author',    contribution_date='2024-01-15') # Query:authors = book.authors.all()books = author1.books.all() # Access through model data:book_authors = BookAuthor.objects.filter(book=book)for ba in book_authors:    print(f"{ba.author.name} - {ba.role}")

ManyToMany Self-Reference

class User(models.Model):    username = models.CharField(max_length=100)    following = models.ManyToManyField(        'self',        symmetrical=False,  # A follows B doesn't mean B follows A        related_name='followers',        blank=True    ) # Usage:user1 = User.objects.create(username='alice')user2 = User.objects.create(username='bob')user3 = User.objects.create(username='charlie') # Alice follows Bob and Charlieuser1.following.add(user2, user3) # Who does Alice follow?following = user1.following.all()  # [bob, charlie] # Who follows Bob?followers = user2.followers.all()  # [alice] # Symmetric example (friends):class User(models.Model):    friends = models.ManyToManyField(        'self',        symmetrical=True,  # If A friends B, then B friends A        blank=True    ) # Usage:user1.friends.add(user2)# Now both:user1.friends.all()  # [user2]user2.friends.all()  # [user1]

Forward Queries (ForeignKey)

class Author(models.Model):    name = models.CharField(max_length=100) class Post(models.Model):    title = models.CharField(max_length=200)    author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name='posts') # Forward query (from Post to Author):post = Post.objects.get(id=1)author = post.author  # Single queryprint(author.name) # Filter by related field:posts = Post.objects.filter(author__name='John')posts = Post.objects.filter(author__id=1)posts = Post.objects.filter(author__name__icontains='john')

Reverse Queries (ForeignKey)

# Reverse query (from Author to Posts):author = Author.objects.get(id=1)posts = author.posts.all()  # Using related_name # Without related_name:posts = author.post_set.all() # Filter reverse:published_posts = author.posts.filter(published=True)recent_posts = author.posts.order_by('-created')[:5] # Exists:has_posts = author.posts.exists() # Count:post_count = author.posts.count() # Reverse filtering in main query:authors = Author.objects.filter(posts__published=True).distinct()authors = Author.objects.filter(posts__title__icontains='django')

ManyToMany Queries

class Post(models.Model):    tags = models.ManyToManyField('Tag', related_name='posts') # Forward:post = Post.objects.get(id=1)tags = post.tags.all()post.tags.add(tag1, tag2) # Reverse:tag = Tag.objects.get(slug='django')posts = tag.posts.all()posts = tag.posts.filter(published=True) # Filter by m2m:posts = Post.objects.filter(tags__name='Django')posts = Post.objects.filter(tags__slug__in=['django', 'python']) # Posts with ALL specified tags:posts = Post.objects.filter(tags__name='Django').filter(tags__name='Python') # Posts with ANY specified tags:from django.db.models import Qposts = Post.objects.filter(Q(tags__name='Django') | Q(tags__name='Python')).distinct()

select_related() and prefetch_related()

N+1 Query Problem

# BAD - N+1 queries:posts = Post.objects.all()  # 1 queryfor post in posts:    print(post.author.name)  # N queries (one per post)! # Total: 1 + N queries # Example with 100 posts = 101 queries!

select_related() - ForeignKey/OneToOne

# GOOD - Use select_related():posts = Post.objects.select_related('author').all()  # 1 query with JOINfor post in posts:    print(post.author.name)  # No additional queries! # Total: 1 query # SQL: SELECT * FROM post INNER JOIN author ON post.author_id = author.id # Multiple relations:posts = Post.objects.select_related('author', 'category').all() # Chained relations:comments = Comment.objects.select_related('post__author').all()for comment in comments:    print(comment.post.author.name)  # No extra queries # Use cases: ForeignKey, OneToOneField (forward)

prefetch_related() - ManyToMany/Reverse FK

# BAD - N+1 with ManyToMany:posts = Post.objects.all()  # 1 queryfor post in posts:    tags = post.tags.all()  # N queries! # GOOD - Use prefetch_related():posts = Post.objects.prefetch_related('tags').all()  # 2 queries totalfor post in posts:    tags = post.tags.all()  # No additional queries! # Query 1: SELECT * FROM post# Query 2: SELECT * FROM tag WHERE id IN (tag_ids from posts) # Reverse ForeignKey:authors = Author.objects.prefetch_related('posts').all()for author in authors:    posts = author.posts.all()  # No extra queries # Multiple prefetch:posts = Post.objects.prefetch_related('tags', 'comments').all() # Chained prefetch:authors = Author.objects.prefetch_related('posts__tags').all()

Combining select_related() and prefetch_related()

# Complex query optimization:posts = Post.objects.select_related(    'author',      # ForeignKey    'category'     # ForeignKey).prefetch_related(    'tags',        # ManyToMany    'comments__author'  # Reverse FK + FK).all() # Now access all without extra queries:for post in posts:    print(post.author.name)      # No query    print(post.category.name)    # No query    for tag in post.tags.all():  # No query        print(tag.name)    for comment in post.comments.all():  # No query        print(comment.author.username)   # No query

Prefetch with Filtering

from django.db.models import Prefetch # Prefetch only published posts:authors = Author.objects.prefetch_related(    Prefetch(        'posts',        queryset=Post.objects.filter(published=True).order_by('-created')    )).all() # Prefetch with select_related:authors = Author.objects.prefetch_related(    Prefetch(        'posts',        queryset=Post.objects.select_related('category')    )).all() # Multiple custom prefetches:posts = Post.objects.prefetch_related(    Prefetch('comments', queryset=Comment.objects.select_related('author')),    Prefetch('tags', queryset=Tag.objects.order_by('name'))).all()

Bài Tập

Bài 1: Blog with Relationships

Task: Build blog system with complete relationships:

# Models:# - Author (name, email, bio)# - Category (name, slug, parent)# - Tag (name, slug)# - Post (title, slug, content, author, category, tags, published, created)# - Comment (post, author, content, parent, approved, created) # Requirements:# 1. One author has many posts (ForeignKey)# 2. One category has many posts (ForeignKey with SET_NULL)# 3. Categories have parent categories (self-referencing FK)# 4. Posts have many tags (ManyToMany)# 5. Posts have many comments (reverse FK)# 6. Comments can have replies (self-referencing FK)# 7. Create profile for Author (OneToOne with User) # Queries to implement:# - Get all posts by author with categories and tags (optimized)# - Get all comments with post and author info (optimized)# - Get category with subcategories and post count# - Get popular tags (tags with most posts)

Bài 2: E-commerce Relationships

Task: Create e-commerce models:

# Models needed:# - Customer (user, phone, address)# - Product (name, price, category, tags)# - Order (customer, status, created)# - OrderItem (order, product, quantity, price) - Through model# - Review (product, customer, rating, comment)# - Wishlist: Customer <-> Product (ManyToMany) # Requirements:# 1. Customer OneToOne with User# 2. Product ManyToMany with Category# 3. Order ForeignKey to Customer# 4. Order ManyToMany to Product through OrderItem# 5. Review connects Customer and Product# 6. Wishlist with timestamps (through model) # Queries:# - Get customer with all orders and items# - Get product with reviews and average rating# - Get order with all items and product details# - Get customer's wishlist with product info

Task: Build social network relationships:

# Models:# - User (extended from auth.User)# - Profile (user, bio, avatar, followers) - OneToOne + M2M self# - Post (author, content, likes, created)# - Comment (post, author, content, parent, created)# - Like (user, post, created) - Through model with timestamp# - Follow (follower, following, created) - Through model # Requirements:# 1. User has Profile (OneToOne with auto-create signal)# 2. Follow system (M2M self, non-symmetrical)# 3. Post with nested comments# 4. Like system with timestamps# 5. Feed generation (posts from followed users) # Queries to optimize:# - Get user feed (posts from following, with likes and comments)# - Get post with all comments, authors, and like count# - Get user profile with follower/following count# - Get trending posts (most likes in last 24h)

Bài 4: Query Optimization

Task: Optimize queries for performance:

# Given these models:# - Author -> Post -> Comment# - Post -> Tag (M2M)# - Post -> Category # Tasks:# 1. Identify N+1 problems in existing code# 2. Use select_related() for FK/OneToOne# 3. Use prefetch_related() for M2M/reverse FK# 4. Combine both for complex queries# 5. Use Prefetch objects for filtered prefetching# 6. Measure query count before/after optimization # Test with Django Debug Toolbar:# pip install django-debug-toolbar# Count queries for:# - List view (posts with author, category, tags)# - Detail view (post with comments, tags, related posts)# - Author page (posts with comments count) # Goal: Reduce queries to minimum

Tài Liệu Tham Khảo

Previous: Bài 20: Testing Basics | Next: Bài 22: File Uploads

#manytomany

Django Model Relationships