Bài 10: QuerySets

Manager và QuerySets

Manager Là Gì?

Manager là interface Django cung cấp để query database. Mỗi model có ít nhất một Manager tên là objects.

# Manager is accessed via Model.objectsfrom blog.models import Post Post.objects  # This is the Manager # Manager provides QuerySet methodsPost.objects.all()      # Returns QuerySetPost.objects.filter()   # Returns QuerySetPost.objects.get()      # Returns single object

QuerySet Là Gì?

QuerySet là collection of database queries. QuerySets are lazy - chỉ hit database khi cần thiết.

# Create QuerySet (no database hit yet)posts = Post.objects.all()  # QuerySet created # Database hit when evaluatedprint(posts)        # Now queries databaselist(posts)        # Queries databaselen(posts)         # Queries databaseposts[0]           # Queries database

QuerySets are Lazy

# Lazy evaluation exampleqs = Post.objects.all()              # No queryqs = qs.filter(published=True)       # Still no queryqs = qs.filter(created__year=2023)   # Still no queryqs = qs.order_by('-created')         # Still no query # NOW database is hitfor post in qs:    print(post.title) # Single SQL query executed:# SELECT * FROM blog_post # WHERE published = TRUE AND YEAR(created) = 2023# ORDER BY created DESC

QuerySet Chaining

# QuerySets can be chainedPost.objects.filter(published=True).filter(views__gte=100).order_by('-created') # Same as combining filtersPost.objects.filter(published=True, views__gte=100).order_by('-created') # Build dynamic queriesqs = Post.objects.all() if published_only:    qs = qs.filter(published=True) if min_views:    qs = qs.filter(views__gte=min_views) if category:    qs = qs.filter(category=category) posts = qs.order_by('-created')[:10]

When QuerySets are Evaluated

# QuerySets are evaluated when: # 1. Iterationfor post in Post.objects.all():    print(post.title) # 2. Slicing with stepPost.objects.all()[:5]        # Not evaluatedPost.objects.all()[5:10]      # Not evaluatedPost.objects.all()[::2]       # Evaluated (has step) # 3. Pickling/Serializingimport picklepickle.dumps(Post.objects.all()) # 4. repr() or str()print(Post.objects.all()) # 5. len()count = len(Post.objects.all()) # 6. list()posts_list = list(Post.objects.all()) # 7. bool()if Post.objects.filter(published=True):    print("Has published posts")

Custom Managers

# blog/models.pyfrom django.db import models class PublishedManager(models.Manager):    """Manager that returns only published posts."""        def get_queryset(self):        return super().get_queryset().filter(published=True) class Post(models.Model):    title = models.CharField(max_length=200)    content = models.TextField()    published = models.BooleanField(default=False)    created = models.DateTimeField(auto_now_add=True)        # Default manager    objects = models.Manager()        # Custom manager    published_posts = PublishedManager() # UsagePost.objects.all()              # All postsPost.published_posts.all()      # Only published posts # Add custom methods to managerclass PostManager(models.Manager):    def published(self):        return self.filter(published=True)        def recent(self, days=7):        from django.utils import timezone        from datetime import timedelta        date = timezone.now() - timedelta(days=days)        return self.filter(created__gte=date) class Post(models.Model):    # ... fields ...    objects = PostManager() # UsagePost.objects.published()              # Published postsPost.objects.recent()                 # Recent postsPost.objects.published().recent()     # Published AND recent

Creating Objects

Method 1: save()

# Create instance then savefrom blog.models import Post post = Post(    title='My First Post',    content='This is the content...',    published=True) post.save()  # INSERT INTO database # Object now has idprint(post.id)  # 1print(post.created)  # 2023-10-28 10:00:00

Method 2: create()

# Create and save in one steppost = Post.objects.create(    title='My Second Post',    content='More content...',    published=True) # Immediately saved, has idprint(post.id)  # 2

Method 3: get_or_create()

# Get existing or create newpost, created = Post.objects.get_or_create(    slug='my-post',    defaults={        'title': 'My Post',        'content': 'Content here',        'published': True    }) if created:    print("New post created")else:    print("Post already exists") # Example: Ensure category existscategory, created = Category.objects.get_or_create(    slug='django',    defaults={'name': 'Django'})

Method 4: update_or_create()

# Update existing or create newpost, created = Post.objects.update_or_create(    slug='my-post',    defaults={        'title': 'Updated Title',        'content': 'Updated content',        'published': True    }) # If post exists: updates fields# If not exists: creates new post

Bulk Create

# Create multiple objects efficientlyposts = [    Post(title='Post 1', content='Content 1'),    Post(title='Post 2', content='Content 2'),    Post(title='Post 3', content='Content 3'),] Post.objects.bulk_create(posts) # More efficient than:for post_data in posts:    Post.objects.create(**post_data) # Batch size for large datasetsPost.objects.bulk_create(posts, batch_size=100) # Note: bulk_create limitations:# - Doesn't call save() method# - Doesn't send signals# - May not return PKs (database-dependent)

Retrieving Objects

all() - Get All Objects

# Get all postsall_posts = Post.objects.all() # Returns QuerySet# Query: SELECT * FROM blog_post for post in all_posts:    print(post.title) # Counttotal = Post.objects.all().count()# Query: SELECT COUNT(*) FROM blog_post

get() - Get Single Object

# Get by primary keypost = Post.objects.get(pk=1)post = Post.objects.get(id=1) # Get by unique fieldpost = Post.objects.get(slug='my-post') # Get with multiple conditionspost = Post.objects.get(title='My Post', published=True) # Exceptions:try:    post = Post.objects.get(slug='non-existent')except Post.DoesNotExist:    print("Post not found") try:    post = Post.objects.get(published=True)  # Multiple resultsexcept Post.MultipleObjectsReturned:    print("Multiple posts found") # Safe alternative: get_object_or_404from django.shortcuts import get_object_or_404 # In viewspost = get_object_or_404(Post, slug='my-post')# Raises Http404 if not found (instead of DoesNotExist)

filter() - Filter Objects

# Basic filterpublished_posts = Post.objects.filter(published=True)# Query: SELECT * FROM blog_post WHERE published = TRUE # Multiple conditions (AND)posts = Post.objects.filter(    published=True,    created__year=2023)# Query: WHERE published = TRUE AND YEAR(created) = 2023 # Chaining filters (same as above)posts = Post.objects.filter(published=True).filter(created__year=2023) # Filter returns QuerySet (even if 0 or 1 result)posts = Post.objects.filter(id=1)  # Returns QuerySet with 1 item

exclude() - Exclude Objects

# Exclude published postsdrafts = Post.objects.exclude(published=True)# Query: WHERE NOT published = TRUE # Multiple excludes (AND)posts = Post.objects.exclude(published=False).exclude(views__lt=10)# Query: WHERE NOT (published = FALSE) AND NOT (views < 10) # Combine filter and excludeposts = Post.objects.filter(created__year=2023).exclude(views__lt=100)# Query: WHERE YEAR(created) = 2023 AND NOT (views < 100)

first() and last()

# first() - First object or Nonelatest_post = Post.objects.order_by('-created').first()if latest_post:    print(latest_post.title) # last() - Last object or Noneoldest_post = Post.objects.order_by('-created').last() # Without ordering, first/last are undefined# Always use with order_by()

exists() - Check Existence

# Check if any posts existhas_posts = Post.objects.filter(published=True).exists()# Returns True/False # More efficient than:if Post.objects.filter(published=True).count() > 0:    pass # Use exists() for checking onlyif Post.objects.filter(author=user, published=True).exists():    print("User has published posts")

Field Lookups

Field lookups specify the WHERE clause. Format: field__lookup=value

Exact Match

# exact - Exact match (case-sensitive)Post.objects.filter(id__exact=1)Post.objects.filter(id=1)  # Same as above (exact is default) # iexact - Case-insensitive exact matchPost.objects.filter(title__iexact='django tutorial')# Matches: "Django Tutorial", "DJANGO TUTORIAL", "django tutorial"

Contains

# contains - Case-sensitive containsPost.objects.filter(title__contains='Django')# Matches: "Django Tutorial", "Learning Django"# Not matches: "django tutorial" (case-sensitive) # icontains - Case-insensitive containsPost.objects.filter(title__icontains='django')# Matches: "Django Tutorial", "django guide", "DJANGO" # Common use: Searchsearch_query = request.GET.get('q', '')posts = Post.objects.filter(    title__icontains=search_query)

Starts/Ends With

# startswith - Starts with (case-sensitive)Post.objects.filter(title__startswith='Django') # istartswith - Case-insensitive starts withPost.objects.filter(title__istartswith='django') # endswith - Ends withPost.objects.filter(title__endswith='Tutorial') # iendswith - Case-insensitive ends withPost.objects.filter(title__iendswith='tutorial')

Comparisons

# gt - Greater thanPost.objects.filter(views__gt=100)# WHERE views > 100 # gte - Greater than or equalPost.objects.filter(views__gte=100)# WHERE views >= 100 # lt - Less thanPost.objects.filter(views__lt=1000)# WHERE views < 1000 # lte - Less than or equalPost.objects.filter(views__lte=1000)# WHERE views <= 1000 # Combine comparisonsPost.objects.filter(views__gte=100, views__lte=1000)# WHERE views >= 100 AND views <= 1000

In List

# in - Value in listPost.objects.filter(id__in=[1, 2, 3, 4, 5])# WHERE id IN (1, 2, 3, 4, 5) # Works with any iterablepost_ids = [1, 2, 3]Post.objects.filter(id__in=post_ids) # Nested querycategories = Category.objects.filter(name__in=['Django', 'Python'])Post.objects.filter(category__in=categories)

Range

# range - Value in range (inclusive)Post.objects.filter(id__range=(1, 100))# WHERE id BETWEEN 1 AND 100 # Date rangeimport datetimestart_date = datetime.date(2023, 1, 1)end_date = datetime.date(2023, 12, 31)Post.objects.filter(created__range=(start_date, end_date))

Date Lookups

from django.utils import timezone # year - Filter by yearPost.objects.filter(created__year=2023) # month - Filter by monthPost.objects.filter(created__month=10) # day - Filter by dayPost.objects.filter(created__day=28) # week - Filter by week numberPost.objects.filter(created__week=42) # week_day - Filter by day of week (1=Sunday, 2=Monday, ...)Post.objects.filter(created__week_day=1)  # Sunday # date - Filter by date (ignores time)today = timezone.now().date()Post.objects.filter(created__date=today) # time - Filter by time (ignores date)Post.objects.filter(created__time__gte='09:00:00') # Combine date lookupsPost.objects.filter(    created__year=2023,    created__month=10,    created__day=28)

Null Lookups

# isnull - Check if nullPost.objects.filter(subtitle__isnull=True)# WHERE subtitle IS NULL Post.objects.filter(subtitle__isnull=False)# WHERE subtitle IS NOT NULL # Exclude null valuesPost.objects.exclude(subtitle__isnull=True)# Same as: filter(subtitle__isnull=False)

# Lookup through ForeignKey# Post has ForeignKey to AuthorPost.objects.filter(author__username='john')# WHERE author.username = 'john' # Multiple levelsPost.objects.filter(author__profile__country='USA') # Reverse lookup# Get authors who have published postsAuthor.objects.filter(post__published=True).distinct()

Ordering Results

order_by()

# Ascending orderPost.objects.order_by('created')# ORDER BY created ASC # Descending order (prefix with -)Post.objects.order_by('-created')# ORDER BY created DESC # Multiple fieldsPost.objects.order_by('-created', 'title')# ORDER BY created DESC, title ASC # Order by related fieldPost.objects.order_by('author__username')Post.objects.order_by('category__name', '-created') # Order by count (requires annotation)from django.db.models import CountPost.objects.annotate(    comment_count=Count('comments')).order_by('-comment_count')

Random Order

# Random orderPost.objects.order_by('?')# Warning: Expensive for large datasets # Better approach for random itemimport randomposts = list(Post.objects.all())random_post = random.choice(posts) if posts else None

reverse()

# Reverse current orderingposts = Post.objects.order_by('created')posts_reversed = posts.reverse()# Same as: order_by('-created') # Only works on QuerySets with orderingPost.objects.all().reverse()  # Error if no orderingPost.objects.order_by('created').reverse()  # OK

Meta Ordering

# Default ordering in model Metaclass Post(models.Model):    title = models.CharField(max_length=200)    created = models.DateTimeField(auto_now_add=True)        class Meta:        ordering = ['-created']  # Default order # Now all queries use this orderingPost.objects.all()  # Automatically ordered by -created # Override default orderingPost.objects.order_by('title')  # Ignores Meta.ordering

Limiting Results

Slicing QuerySets

# First 5 postsPost.objects.all()[:5]# LIMIT 5 # Posts 5-10Post.objects.all()[5:10]# OFFSET 5 LIMIT 5 # Skip first 10Post.objects.all()[10:]# OFFSET 10 # Get single item (evaluates QuerySet)first_post = Post.objects.all()[0]# Raises IndexError if no results # Safe alternativefirst_post = Post.objects.all().first()# Returns None if no results

Negative Indexing NOT Supported

# This does NOT work:Post.objects.all()[-1]  # Error! # Use reverse() instead:Post.objects.order_by('-created').first()  # Last created

Pagination Example

# Simple paginationpage = 2page_size = 10offset = (page - 1) * page_size posts = Post.objects.all()[offset:offset + page_size] # In viewsfrom django.core.paginator import Paginator def post_list(request):    all_posts = Post.objects.all()    paginator = Paginator(all_posts, 10)  # 10 per page        page_number = request.GET.get('page', 1)    page_obj = paginator.get_page(page_number)        return render(request, 'posts.html', {'posts': page_obj})

Bài Tập

Bài 1: Basic Queries

Task: Practice basic QuerySet operations:

# Given Post model:# - title, content, published, views, created # Write queries for:# 1. Get all published posts# 2. Get posts created in 2023# 3. Get posts with more than 1000 views# 4. Get posts containing "Django" in title (case-insensitive)# 5. Count total published posts# 6. Get latest 10 posts# 7. Check if any draft posts exist# 8. Get post with slug='django-tutorial' (use get_object_or_404)

Bài 2: Field Lookups

Task: Use various field lookups:

# Write queries using field lookups:# 1. Posts with views between 100 and 1000# 2. Posts created in October 2023# 3. Posts where title starts with "Python"# 4. Posts where subtitle is null# 5. Posts with id in list [1, 5, 10, 15]# 6. Posts created on weekends (Saturday or Sunday)# 7. Posts created today# 8. Posts by authors with username containing "john"

Bài 3: Ordering and Limiting

Task: Practice ordering and limiting:

# Write queries for:# 1. Latest 5 posts ordered by created date# 2. Posts ordered by views (highest first), then by title# 3. Posts ordered by author username, then by created date# 4. Get 10 posts starting from post 20 (pagination)# 5. Most viewed post# 6. Oldest published post# 7. Random 5 posts# 8. Second page of posts (10 per page)

Bài 4: Complex Queries

Task: Combine multiple QuerySet operations:

# Write queries for:# 1. Published posts from 2023 with >500 views, ordered by views# 2. Draft posts containing "tutorial" in title, latest first# 3. Posts by specific author, published, from last 30 days# 4. Top 10 most viewed published posts from this year# 5. Posts without category (category is null)# 6. Posts created in last 7 days, exclude views < 50

Tài Liệu Tham Khảo

Previous: Bài 09.2: Admin Advanced | Next: Bài 11: CRUD Operations

#manager

Django QuerySets