Bài 24: Search & Filtering

Basic Filtering

Filtering cho phép query dữ liệu theo conditions cụ thể.

from django.shortcuts import renderfrom .models import Post def post_list(request):    # Basic filtering    posts = Post.objects.filter(published=True)        # Multiple conditions (AND)    posts = Post.objects.filter(        published=True,        featured=True    )        # Chaining filters (same as above)    posts = Post.objects.filter(published=True).filter(featured=True)        # Exclude    posts = Post.objects.exclude(status='draft')        # All objects    posts = Post.objects.all()        return render(request, 'blog/post_list.html', {'posts': posts})

Field Lookups

Common Lookups

# Exact match (default)Post.objects.filter(id=1)Post.objects.filter(id__exact=1) # Case-insensitive exactPost.objects.filter(title__iexact='django')  # Matches 'Django', 'DJANGO', 'django' # ContainsPost.objects.filter(title__contains='Django')  # Case-sensitivePost.objects.filter(title__icontains='django')  # Case-insensitive # Starts with / Ends withPost.objects.filter(title__startswith='How to')Post.objects.filter(title__istartswith='how to')Post.objects.filter(title__endswith='Tutorial')Post.objects.filter(title__iendswith='tutorial') # In listPost.objects.filter(status__in=['published', 'featured'])Post.objects.filter(id__in=[1, 2, 3, 4, 5]) # Greater than / Less thanfrom datetime import date, timedeltatoday = date.today()week_ago = today - timedelta(days=7) Post.objects.filter(created__gt=week_ago)   # Greater thanPost.objects.filter(created__gte=today)     # Greater than or equalPost.objects.filter(created__lt=today)      # Less thanPost.objects.filter(created__lte=today)     # Less than or equal # RangePost.objects.filter(views__range=(100, 1000))Post.objects.filter(created__range=(week_ago, today)) # Is nullPost.objects.filter(published_date__isnull=True)Post.objects.filter(published_date__isnull=False) # RegexPost.objects.filter(title__regex=r'^[A-Z]')   # Case-sensitivePost.objects.filter(title__iregex=r'^django')  # Case-insensitive

# Filter by related fieldposts = Post.objects.filter(author__username='john')posts = Post.objects.filter(author__email__endswith='@gmail.com')posts = Post.objects.filter(category__name='Technology') # Multiple levelsposts = Post.objects.filter(author__profile__country='USA') # Reverse relationshipauthors = Author.objects.filter(posts__published=True)categories = Category.objects.filter(posts__views__gte=1000) # ManyToManyposts = Post.objects.filter(tags__name='Django')posts = Post.objects.filter(tags__slug__in=['python', 'django'])

Q Objects

Basic Q Objects

from django.db.models import Q # OR conditionposts = Post.objects.filter(    Q(title__icontains='django') | Q(content__icontains='django'))# SQL: WHERE title LIKE '%django%' OR content LIKE '%django%' # AND conditionposts = Post.objects.filter(    Q(published=True) & Q(featured=True))# Same as: Post.objects.filter(published=True, featured=True) # NOT conditionposts = Post.objects.filter(~Q(status='draft'))# Same as: Post.objects.exclude(status='draft') # Complex combinationsposts = Post.objects.filter(    Q(title__icontains='python') &     (Q(author__username='john') | Q(author__username='jane')))# SQL: WHERE title LIKE '%python%' AND (author='john' OR author='jane')

Advanced Q Object Usage

from django.db.models import Q def search_posts(request):    query = request.GET.get('q', '')        if query:        # Search in multiple fields        posts = Post.objects.filter(            Q(title__icontains=query) |            Q(content__icontains=query) |            Q(author__username__icontains=query) |            Q(tags__name__icontains=query)        ).distinct()    else:        posts = Post.objects.all()        return render(request, 'blog/search.html', {        'posts': posts,        'query': query    }) # Dynamic Q objectsdef build_search_query(search_term, fields):    """Build Q object for searching multiple fields"""    query = Q()        for field in fields:        query |= Q(**{f'{field}__icontains': search_term})        return query # Usage:search_fields = ['title', 'content', 'author__username']posts = Post.objects.filter(    build_search_query('django', search_fields))

Combining Q Objects

# Build complex queries dynamicallydef advanced_search(title=None, author=None, category=None, min_views=None):    query = Q()        if title:        query &= Q(title__icontains=title)        if author:        query &= Q(author__username__icontains=author)        if category:        query &= Q(category__slug=category)        if min_views:        query &= Q(views__gte=min_views)        return Post.objects.filter(query) # Usage:posts = advanced_search(    title='django',    category='technology',    min_views=100)

Search Forms

# forms.pyfrom django import forms class SearchForm(forms.Form):    query = forms.CharField(        max_length=100,        required=False,        widget=forms.TextInput(attrs={            'placeholder': 'Search...',            'class': 'form-control'        })    ) # views.pyfrom django.db.models import Q def search(request):    form = SearchForm(request.GET)    posts = Post.objects.none()        if form.is_valid():        query = form.cleaned_data.get('query')                if query:            posts = Post.objects.filter(                Q(title__icontains=query) |                Q(content__icontains=query)            ).distinct()        return render(request, 'blog/search.html', {        'form': form,        'posts': posts,        'query': query    }) # Template:<form method="get" action="{% url 'search' %}">    {{ form.query }}    <button type="submit">Search</button></form> {% for post in posts %}    <h3>{{ post.title }}</h3>{% empty %}    <p>No results found.</p>{% endfor %}

# forms.pyclass AdvancedSearchForm(forms.Form):    query = forms.CharField(max_length=100, required=False)    category = forms.ModelChoiceField(        queryset=Category.objects.all(),        required=False,        empty_label='All Categories'    )    author = forms.ModelChoiceField(        queryset=Author.objects.all(),        required=False,        empty_label='All Authors'    )    date_from = forms.DateField(required=False, widget=forms.DateInput(attrs={'type': 'date'}))    date_to = forms.DateField(required=False, widget=forms.DateInput(attrs={'type': 'date'}))    min_views = forms.IntegerField(required=False, min_value=0) # views.pydef advanced_search(request):    form = AdvancedSearchForm(request.GET)    posts = Post.objects.all()        if form.is_valid():        query = form.cleaned_data.get('query')        category = form.cleaned_data.get('category')        author = form.cleaned_data.get('author')        date_from = form.cleaned_data.get('date_from')        date_to = form.cleaned_data.get('date_to')        min_views = form.cleaned_data.get('min_views')                # Build query        q_objects = Q()                if query:            q_objects &= (                Q(title__icontains=query) |                Q(content__icontains=query)            )                if category:            q_objects &= Q(category=category)                if author:            q_objects &= Q(author=author)                if date_from:            q_objects &= Q(created__gte=date_from)                if date_to:            q_objects &= Q(created__lte=date_to)                if min_views:            q_objects &= Q(views__gte=min_views)                posts = posts.filter(q_objects).distinct()        return render(request, 'blog/advanced_search.html', {        'form': form,        'posts': posts    })

Filter with URL Parameters

Basic URL Filtering

# views.pydef post_list(request):    posts = Post.objects.all()        # Filter by category    category_slug = request.GET.get('category')    if category_slug:        posts = posts.filter(category__slug=category_slug)        # Filter by author    author_id = request.GET.get('author')    if author_id:        posts = posts.filter(author_id=author_id)        # Filter by tag    tag_slug = request.GET.get('tag')    if tag_slug:        posts = posts.filter(tags__slug=tag_slug)        # Sort    sort_by = request.GET.get('sort', '-created')    posts = posts.order_by(sort_by)        return render(request, 'blog/post_list.html', {        'posts': posts,        'current_category': category_slug,        'current_tag': tag_slug,    }) # URLs:# /posts/?category=technology# /posts/?author=1&sort=title# /posts/?tag=python&category=technology

Filter with ListView

from django.views.generic import ListViewfrom django.db.models import Q class PostListView(ListView):    model = Post    template_name = 'blog/post_list.html'    context_object_name = 'posts'    paginate_by = 10        def get_queryset(self):        queryset = super().get_queryset()                # Search        query = self.request.GET.get('q')        if query:            queryset = queryset.filter(                Q(title__icontains=query) |                Q(content__icontains=query)            )                # Category filter        category = self.request.GET.get('category')        if category:            queryset = queryset.filter(category__slug=category)                # Author filter        author = self.request.GET.get('author')        if author:            queryset = queryset.filter(author__username=author)                # Tag filter        tag = self.request.GET.get('tag')        if tag:            queryset = queryset.filter(tags__slug=tag)                # Date range        date_from = self.request.GET.get('from')        date_to = self.request.GET.get('to')        if date_from:            queryset = queryset.filter(created__gte=date_from)        if date_to:            queryset = queryset.filter(created__lte=date_to)                # Sort        sort = self.request.GET.get('sort', '-created')        allowed_sorts = ['created', '-created', 'title', '-title', 'views', '-views']        if sort in allowed_sorts:            queryset = queryset.order_by(sort)                return queryset.distinct()        def get_context_data(self, **kwargs):        context = super().get_context_data(**kwargs)                # Add filter values to context        context['query'] = self.request.GET.get('q', '')        context['category'] = self.request.GET.get('category', '')        context['tag'] = self.request.GET.get('tag', '')        context['sort'] = self.request.GET.get('sort', '-created')                # Add filter options        context['categories'] = Category.objects.all()        context['tags'] = Tag.objects.all()                return context

Search Optimization

Using Indexes

# models.pyclass Post(models.Model):    title = models.CharField(max_length=200, db_index=True)    slug = models.SlugField(unique=True, db_index=True)    content = models.TextField()    author = models.ForeignKey(User, on_delete=models.CASCADE, db_index=True)    created = models.DateTimeField(auto_now_add=True, db_index=True)        class Meta:        indexes = [            models.Index(fields=['title', 'created']),            models.Index(fields=['author', 'created']),            models.Index(fields=['-created']),        ]

select_related and prefetch_related

# Optimize queriesdef post_list(request):    posts = Post.objects.select_related(        'author',        'category'    ).prefetch_related(        'tags',        'comments'    ).filter(published=True)        return render(request, 'blog/post_list.html', {'posts': posts}) # With search:def search(request):    query = request.GET.get('q')        posts = Post.objects.select_related(        'author',        'category'    ).prefetch_related(        'tags'    ).filter(        Q(title__icontains=query) |        Q(content__icontains=query)    ).distinct()        return render(request, 'blog/search.html', {        'posts': posts,        'query': query    })

Full-Text Search (PostgreSQL)

# Requires PostgreSQLfrom django.contrib.postgres.search import SearchVector, SearchQuery, SearchRank def full_text_search(request):    query = request.GET.get('q')        if query:        # Simple search        posts = Post.objects.annotate(            search=SearchVector('title', 'content')        ).filter(search=query)                # Weighted search (title more important)        posts = Post.objects.annotate(            search=SearchVector('title', weight='A') +                    SearchVector('content', weight='B')        ).filter(search=query)                # Ranked search        search_query = SearchQuery(query)        posts = Post.objects.annotate(            search=SearchVector('title', 'content'),            rank=SearchRank(SearchVector('title', 'content'), search_query)        ).filter(search=search_query).order_by('-rank')    else:        posts = Post.objects.none()        return render(request, 'blog/search.html', {        'posts': posts,        'query': query    }) # Add search index to model:class Post(models.Model):    # ... fields ...        class Meta:        indexes = [            GinIndex(fields=['title', 'content']),  # For full-text search        ]

django-filter

# Install: pip install django-filter # settings.pyINSTALLED_APPS = [    # ...    'django_filters',] # filters.pyimport django_filtersfrom .models import Post class PostFilter(django_filters.FilterSet):    title = django_filters.CharFilter(lookup_expr='icontains')    author = django_filters.CharFilter(field_name='author__username', lookup_expr='icontains')    min_views = django_filters.NumberFilter(field_name='views', lookup_expr='gte')    max_views = django_filters.NumberFilter(field_name='views', lookup_expr='lte')    created_after = django_filters.DateFilter(field_name='created', lookup_expr='gte')    created_before = django_filters.DateFilter(field_name='created', lookup_expr='lte')        class Meta:        model = Post        fields = ['category', 'tags', 'published'] # views.pyfrom .filters import PostFilter def post_list(request):    post_filter = PostFilter(request.GET, queryset=Post.objects.all())        return render(request, 'blog/post_list.html', {        'filter': post_filter    }) # Template:<form method="get">    {{ filter.form.as_p }}    <button type="submit">Filter</button></form> {% for post in filter.qs %}    <h3>{{ post.title }}</h3>{% endfor %} # With ListView:from django_filters.views import FilterView class PostListView(FilterView):    model = Post    filterset_class = PostFilter    template_name = 'blog/post_list.html'    paginate_by = 10

AJAX Search

Live Search

# views.pyfrom django.http import JsonResponse def live_search(request):    query = request.GET.get('q', '')        if len(query) >= 3:  # Min 3 characters        posts = Post.objects.filter(            Q(title__icontains=query) |            Q(content__icontains=query)        ).select_related('author')[:10]                results = [{            'id': post.id,            'title': post.title,            'url': post.get_absolute_url(),            'author': post.author.username,            'excerpt': post.content[:100],        } for post in posts]                return JsonResponse({'results': results})        return JsonResponse({'results': []}) # JavaScript:// static/js/live-search.jsconst searchInput = document.getElementById('search-input');const resultsDiv = document.getElementById('search-results'); let searchTimeout; searchInput.addEventListener('input', function(e) {    clearTimeout(searchTimeout);        const query = e.target.value;        if (query.length < 3) {        resultsDiv.innerHTML = '';        return;    }        searchTimeout = setTimeout(() => {        fetch(`/search/live/?q=${encodeURIComponent(query)}`)            .then(response => response.json())            .then(data => {                displayResults(data.results);            });    }, 300); // Debounce 300ms}); function displayResults(results) {    if (results.length === 0) {        resultsDiv.innerHTML = '<p>No results found</p>';        return;    }        const html = results.map(post => `        <div class="search-result">            <a href="${post.url}">                <h4>${post.title}</h4>                <p>${post.excerpt}...</p>                <small>By ${post.author}</small>            </a>        </div>    `).join('');        resultsDiv.innerHTML = html;}

Bài Tập

Bài 1: Blog Search System

Task: Implement complete search system:

# Requirements:# 1. Search form in header (visible on all pages)# 2. Search posts by title, content, author name# 3. Highlight search terms in results# 4. Show result count and search time# 5. Empty state when no results# 6. Preserve search query in form after submit# 7. Pagination for search results# 8. Sort options (relevance, date, views)# 9. Recent searches (stored in session)# 10. Search suggestions (did you mean?)

Task: Create advanced product filtering:

# Requirements:# 1. Filter by: category, price range, brand, rating# 2. Multi-select filters (multiple categories, brands)# 3. Price range slider# 4. Color/size filters (if applicable)# 5. In stock / On sale toggles# 6. Sort by: price, popularity, newest, rating# 7. Clear all filters button# 8. Show active filters with remove option# 9. Update URL with filter parameters# 10. Product count for each filter option# 11. AJAX filter updates (no page reload)# 12. Mobile-friendly filter sidebar

Bài 3: Advanced Search Interface

Task: Build advanced search with multiple options:

# Requirements:# 1. Basic search (simple query)# 2. Advanced search toggle with more options:#    - Exact phrase#    - All words / Any words / Exclude words#    - Author#    - Category#    - Date range#    - Has comments#    - View count range# 3. Save search queries# 4. Search history (last 10 searches)# 5. Export search results (CSV/JSON)# 6. Share search URL# 7. Search within results# 8. Faceted search (show filter counts)

Bài 4: Full-Text Search

Task: Implement full-text search with PostgreSQL:

# Requirements:# 1. Set up PostgreSQL full-text search# 2. SearchVector for multiple fields# 3. Weighted search (title > content > comments)# 4. SearchRank for relevance sorting# 5. Search highlighting (show matched text)# 6. Autocomplete suggestions# 7. Fuzzy matching (handle typos)# 8. Synonym support# 9. Stop words handling# 10. Search analytics (track popular searches)# 11. Performance optimization with GIN index# 12. Fallback to basic search if not PostgreSQL

Tài Liệu Tham Khảo

Previous: Bài 23: Pagination | Next: Bài 25: Slugs and SEO

#field-lookups

Django Search & Filtering