Bài 9.3: Filtering, Searching & Pagination - Phần 3 - Searching

**Series Navigation:** - [Bài 9.1: Basic Filtering](/django-advance/filtering-searching-pagination-phan-1) - [Bài 9.2: Advanced Filtering](/django-advance/filtering-searching-pagination-phan-2) - **Bài 9.3 (bài này): Searching** 👈 - [Bài 9.4: Pagination](/django-advance/filtering-searching-pagination-phan-4)

Mục Tiêu Bài 9.3

Sau khi hoàn thành Bài 9.3 này, bạn sẽ:

✅ Implement SearchFilter
✅ Configure search fields
✅ Use PostgreSQL full-text search
✅ Integrate Elasticsearch
✅ Optimize search queries
✅ Handle search ranking

Installation & Setup

# views.pyfrom rest_framework import filters class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    filter_backends = [filters.SearchFilter]    search_fields = ['title', 'content'] # Usage:# /api/articles/?search=django# Searches in title and content fields

Search Field Syntax

Exact match (^):

search_fields = ['^title'] # /api/articles/?search=django# Finds: title LIKE 'django%'# Matches: "Django Tutorial", "django-rest-framework"# Doesn't match: "Learn Django"

Word boundary ($):

search_fields = ['$title'] # /api/articles/?search=django# Finds: title REGEXP r'\bdjango\b'# Matches: "Django Tutorial", "Learn Django"# Doesn't match: "django-rest-framework"

Contains (=):

search_fields = ['=title'] # /api/articles/?search=django# Finds: title = 'django' (exact match)# Only matches: "django" (case-insensitive by default)

Default (no prefix) = icontains:

search_fields = ['title'] # /api/articles/?search=django# Finds: title ILIKE '%django%'# Matches: "Django Tutorial", "Learn Django", "django-rest-framework"

Multiple Search Fields

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    filter_backends = [filters.SearchFilter]    search_fields = [        'title',           # Contains in title        'content',         # Contains in content        '^author__username',  # Starts with in author username    ] # /api/articles/?search=django# Searches: title ILIKE '%django%' OR #           content ILIKE '%django%' OR #           author__username ILIKE 'django%'

Combining with Filters

from django_filters.rest_framework import DjangoFilterBackend class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    filter_backends = [        DjangoFilterBackend,        filters.SearchFilter,        filters.OrderingFilter    ]    filterset_class = ArticleFilter    search_fields = ['title', 'content', 'author__username']    ordering_fields = ['created_at', 'views'] # Combined usage:# /api/articles/?status=published&search=django&ordering=-views# Filter by status, search for "django", order by views descending

Custom Search Implementation

Override get_search_fields

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    filter_backends = [filters.SearchFilter]        def get_search_fields(self):        """        Dynamically determine search fields        """        # Staff can search by more fields        if self.request.user.is_staff:            return ['title', 'content', 'author__username', 'author__email']                # Regular users: limited search        return ['title', 'content']

Custom Search Logic

class CustomSearchFilter(filters.SearchFilter):    """    Custom search with additional logic    """        def filter_queryset(self, request, queryset, view):        search_terms = self.get_search_terms(request)                if not search_terms:            return queryset                # Get search fields        search_fields = self.get_search_fields(view, request)                # Build queries        from django.db.models import Q                queries = Q()                for search_term in search_terms:            term_queries = Q()                        for search_field in search_fields:                # Custom logic: boost title matches                if 'title' in search_field:                    # Title match is more important                    term_queries |= Q(**{f'{search_field}__icontains': search_term})                else:                    term_queries |= Q(**{f'{search_field}__icontains': search_term})                        queries &= term_queries                return queryset.filter(queries).distinct() class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    filter_backends = [CustomSearchFilter]    search_fields = ['title', 'content']

Weighted Search

class WeightedSearchFilter(filters.SearchFilter):    """    Search with field weights    """        def filter_queryset(self, request, queryset, view):        search_terms = self.get_search_terms(request)                if not search_terms:            return queryset                from django.db.models import Q, Value, Case, When, IntegerField                # Build search query        search_query = ' '.join(search_terms)                # Add relevance score        queryset = queryset.annotate(            relevance=Case(                # Title exact match: weight 10                When(title__iexact=search_query, then=Value(10)),                # Title starts with: weight 5                When(title__istartswith=search_query, then=Value(5)),                # Title contains: weight 3                When(title__icontains=search_query, then=Value(3)),                # Content contains: weight 1                When(content__icontains=search_query, then=Value(1)),                default=Value(0),                output_field=IntegerField()            )        ).filter(relevance__gt=0).order_by('-relevance')                return queryset class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    filter_backends = [WeightedSearchFilter]    search_fields = ['title', 'content']

PostgreSQL Full-Text Search

Setup

# models.pyfrom django.contrib.postgres.search import SearchVectorFieldfrom django.contrib.postgres.indexes import GinIndex class Article(models.Model):    title = models.CharField(max_length=200)    content = models.TextField()    search_vector = SearchVectorField(null=True)        class Meta:        indexes = [            GinIndex(fields=['search_vector']),        ]

Create Search Vector

# Migrationpython manage.py makemigrationspython manage.py migrate

# Update search vectorsfrom django.contrib.postgres.search import SearchVectorfrom myapp.models import Article # Update all articlesArticle.objects.update(    search_vector=SearchVector('title', weight='A') +                   SearchVector('content', weight='B'))

Auto-update Search Vector

# models.pyfrom django.db.models.signals import pre_savefrom django.dispatch import receiverfrom django.contrib.postgres.search import SearchVector @receiver(pre_save, sender=Article)def update_search_vector(sender, instance, **kwargs):    """Update search vector before saving"""    instance.search_vector = (        SearchVector('title', weight='A') +         SearchVector('content', weight='B')    )

Search with SearchVector

# filters.pyfrom django.contrib.postgres.search import SearchQuery, SearchRankfrom rest_framework import filters class PostgresSearchFilter(filters.BaseFilterBackend):    """    PostgreSQL full-text search    """        def filter_queryset(self, request, queryset, view):        search_param = request.query_params.get('search')                if not search_param:            return queryset                # Create search query        search_query = SearchQuery(search_param)                # Filter and rank        queryset = queryset.filter(            search_vector=search_query        ).annotate(            rank=SearchRank('search_vector', search_query)        ).order_by('-rank')                return queryset # views.pyclass ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    filter_backends = [PostgresSearchFilter]

Advanced PostgreSQL Search

from django.contrib.postgres.search import (    SearchQuery, SearchRank, SearchVector, TrigramSimilarity) class AdvancedPostgresSearchFilter(filters.BaseFilterBackend):    """    Advanced PostgreSQL search with:    - Full-text search    - Trigram similarity    - Weighted ranking    """        def filter_queryset(self, request, queryset, view):        search_param = request.query_params.get('search')                if not search_param:            return queryset                # Full-text search query        search_query = SearchQuery(search_param)                # Search in multiple fields with weights        search_vector = (            SearchVector('title', weight='A') +            SearchVector('content', weight='B')        )                # Calculate rank        search_rank = SearchRank(search_vector, search_query)                # Calculate trigram similarity for fuzzy matching        title_similarity = TrigramSimilarity('title', search_param)                # Combine: full-text search OR similar titles        from django.db.models import Q                queryset = queryset.annotate(            rank=search_rank,            similarity=title_similarity        ).filter(            Q(search_vector=search_query) |            Q(similarity__gt=0.3)        ).order_by('-rank', '-similarity')                return queryset

Search Configuration

from django.contrib.postgres.search import SearchQuery, SearchConfig # English search configurationsearch_query = SearchQuery('running', config='english')# Stems: running → run, runs → run # Simple configuration (no stemming)search_query = SearchQuery('running', config='simple')# No stemming # Usage in filterclass PostgresSearchFilter(filters.BaseFilterBackend):    def filter_queryset(self, request, queryset, view):        search_param = request.query_params.get('search')                if not search_param:            return queryset                # Detect language or use default        config = request.query_params.get('lang', 'english')                search_query = SearchQuery(search_param, config=config)                queryset = queryset.filter(            search_vector=search_query        ).annotate(            rank=SearchRank('search_vector', search_query)        ).order_by('-rank')                return queryset

Elasticsearch Integration

Installation

pip install elasticsearchpip install elasticsearch-dslpip install django-elasticsearch-dsl

Configuration

# settings.pyINSTALLED_APPS = [    # ...    'django_elasticsearch_dsl',] ELASTICSEARCH_DSL = {    'default': {        'hosts': 'localhost:9200'    },}

Define Document

# documents.pyfrom django_elasticsearch_dsl import Document, fieldsfrom django_elasticsearch_dsl.registries import registryfrom myapp.models import Article @registry.register_documentclass ArticleDocument(Document):    author = fields.ObjectField(properties={        'id': fields.IntegerField(),        'username': fields.TextField(),    })        category = fields.ObjectField(properties={        'id': fields.IntegerField(),        'name': fields.TextField(),    })        tags = fields.NestedField(properties={        'id': fields.IntegerField(),        'name': fields.TextField(),    })        class Index:        name = 'articles'        settings = {            'number_of_shards': 1,            'number_of_replicas': 0        }        class Django:        model = Article        fields = [            'id',            'title',            'content',            'status',            'views',            'likes',            'created_at',            'updated_at',        ]        related_models = [User, Category, Tag]        def get_queryset(self):        """Select related to avoid N+1"""        return super().get_queryset().select_related(            'author', 'category'        ).prefetch_related('tags')

Index Data

# Create indexpython manage.py search_index --rebuild # Update indexpython manage.py search_index --update # Delete indexpython manage.py search_index --delete

Search with Elasticsearch

# views.pyfrom django_elasticsearch_dsl_drf.viewsets import DocumentViewSetfrom django_elasticsearch_dsl_drf.filter_backends import (    FilteringFilterBackend,    SearchFilterBackend,    OrderingFilterBackend,)from myapp.documents import ArticleDocumentfrom myapp.serializers import ArticleDocumentSerializer class ArticleDocumentViewSet(DocumentViewSet):    document = ArticleDocument    serializer_class = ArticleDocumentSerializer        filter_backends = [        FilteringFilterBackend,        SearchFilterBackend,        OrderingFilterBackend,    ]        # Search fields    search_fields = {        'title': {'boost': 4},        'content': {'boost': 2},        'author.username': {'boost': 1},    }        # Filter fields    filter_fields = {        'status': 'status',        'author.id': 'author.id',        'category.id': 'category.id',    }        # Ordering fields    ordering_fields = {        'created_at': 'created_at',        'views': 'views',        'likes': 'likes',    }        ordering = ('-created_at',) # Usage:# /api/articles/?search=django# /api/articles/?search=django&status=published# /api/articles/?search=django&ordering=-views

Custom Elasticsearch Query

from elasticsearch_dsl import Q as ES_Q class ArticleDocumentViewSet(DocumentViewSet):    document = ArticleDocument    serializer_class = ArticleDocumentSerializer        def filter_queryset(self, queryset):        search_param = self.request.query_params.get('search')                if search_param:            # Multi-match query            query = ES_Q(                'multi_match',                query=search_param,                fields=['title^4', 'content^2', 'author.username'],                fuzziness='AUTO'            )                        queryset = queryset.query(query)                return queryset

Search Optimization

Add Database Indexes

# models.pyclass Article(models.Model):    title = models.CharField(max_length=200, db_index=True)    content = models.TextField()        class Meta:        indexes = [            models.Index(fields=['title']),            # For PostgreSQL full-text search            GinIndex(fields=['search_vector']),        ]

Limit Search Results

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    filter_backends = [filters.SearchFilter]    search_fields = ['title', 'content']        def filter_queryset(self, queryset):        queryset = super().filter_queryset(queryset)                # Limit search results        search = self.request.query_params.get('search')        if search:            queryset = queryset[:100]  # Max 100 results                return queryset

Cache Search Results

from django.core.cache import cachefrom django.utils.encoding import force_str class CachedSearchFilter(filters.SearchFilter):    """    Cache search results    """    cache_timeout = 300  # 5 minutes        def filter_queryset(self, request, queryset, view):        search_terms = self.get_search_terms(request)                if not search_terms:            return queryset                # Create cache key        cache_key = f"search:{force_str(search_terms)}:{queryset.model.__name__}"                # Check cache        cached_ids = cache.get(cache_key)                if cached_ids is not None:            # Return cached results            return queryset.filter(id__in=cached_ids)                # Perform search        filtered_queryset = super().filter_queryset(request, queryset, view)                # Cache IDs        ids = list(filtered_queryset.values_list('id', flat=True)[:100])        cache.set(cache_key, ids, self.cache_timeout)                return filtered_queryset class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    filter_backends = [CachedSearchFilter]    search_fields = ['title', 'content']

Defer Large Fields

class ArticleViewSet(viewsets.ModelViewSet):    serializer_class = ArticleSerializer    filter_backends = [filters.SearchFilter]    search_fields = ['title', 'content']        def get_queryset(self):        queryset = Article.objects.all()                # For list view with search, defer large fields        if self.action == 'list' and 'search' in self.request.query_params:            queryset = queryset.only('id', 'title', 'status', 'created_at')                return queryset

Search Best Practices

1. Use Appropriate Search Method

# Simple search: SearchFiltersearch_fields = ['title', 'content'] # Medium complexity: PostgreSQL full-text search# Good for most applications # High complexity: Elasticsearch# For large datasets, advanced features

2. Limit Searchable Fields

# Bad: Search in many fieldssearch_fields = [    'title', 'content', 'summary', 'meta_description',    'author__username', 'author__email', 'author__bio',    'category__name', 'category__description'] # Good: Focus on important fieldssearch_fields = [    'title',           # Main field    'content',         # Content    'author__username' # Related]

3. Add Minimum Search Length

class MinLengthSearchFilter(filters.SearchFilter):    """    Require minimum search term length    """    min_length = 3        def filter_queryset(self, request, queryset, view):        search_terms = self.get_search_terms(request)                # Check minimum length        if search_terms and all(len(term) < self.min_length for term in search_terms):            # Return empty queryset for too-short searches            return queryset.none()                return super().filter_queryset(request, queryset, view)

4. Sanitize Search Input

class SafeSearchFilter(filters.SearchFilter):    """    Sanitize search input    """        def get_search_terms(self, request):        params = request.query_params.get(self.search_param, '')                # Remove special characters        import re        params = re.sub(r'[^\w\s-]', '', params)                # Limit length        params = params[:100]                return params.replace(',', ' ').split()

Complete Search Example

# models.pyfrom django.db import modelsfrom django.contrib.auth.models import Userfrom django.contrib.postgres.search import SearchVectorFieldfrom django.contrib.postgres.indexes import GinIndex class Article(models.Model):    title = models.CharField(max_length=200, db_index=True)    content = models.TextField()    author = models.ForeignKey(User, on_delete=models.CASCADE)    status = models.CharField(max_length=20, default='draft')    views = models.IntegerField(default=0)    created_at = models.DateTimeField(auto_now_add=True)    search_vector = SearchVectorField(null=True)        class Meta:        indexes = [            GinIndex(fields=['search_vector']),            models.Index(fields=['title', 'status']),        ] # signals.pyfrom django.db.models.signals import pre_savefrom django.dispatch import receiverfrom django.contrib.postgres.search import SearchVector @receiver(pre_save, sender=Article)def update_search_vector(sender, instance, **kwargs):    instance.search_vector = (        SearchVector('title', weight='A', config='english') +        SearchVector('content', weight='B', config='english')    ) # filters.pyfrom django.contrib.postgres.search import SearchQuery, SearchRank, TrigramSimilarityfrom rest_framework import filtersfrom django.db.models import Q class AdvancedSearchFilter(filters.BaseFilterBackend):    """    Advanced search with PostgreSQL full-text + fuzzy matching    """    search_param = 'search'    min_length = 2        def filter_queryset(self, request, queryset, view):        search_param = request.query_params.get(self.search_param)                if not search_param:            return queryset                # Check minimum length        if len(search_param) < self.min_length:            return queryset.none()                # Full-text search        search_query = SearchQuery(search_param, config='english')                # Trigram similarity        title_similarity = TrigramSimilarity('title', search_param)                # Combined query        queryset = queryset.annotate(            rank=SearchRank('search_vector', search_query),            similarity=title_similarity        ).filter(            Q(search_vector=search_query) |            Q(similarity__gt=0.3)        ).order_by('-rank', '-similarity')                return queryset # views.pyfrom django_filters.rest_framework import DjangoFilterBackendfrom rest_framework import filters as drf_filters class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.select_related('author').all()    serializer_class = ArticleSerializer    filter_backends = [        DjangoFilterBackend,        AdvancedSearchFilter,        drf_filters.OrderingFilter    ]    filterset_class = ArticleFilter    ordering_fields = ['created_at', 'views', 'rank']    ordering = ['-created_at'] # Usage:# /api/articles/?search=django# /api/articles/?search=django&status=published# /api/articles/?search=django&ordering=-rank

Tóm Tắt Bài 9.3

Trong Bài 9.3 này, bạn đã học:

✅ SearchFilter:

Basic setup
Search field syntax (^, $, =)
Multiple search fields
Combining with filters

✅ Custom Search:

Override get_search_fields
Custom search logic
Weighted search
Relevance scoring

✅ PostgreSQL Full-Text Search:

SearchVector setup
Auto-update search vector
SearchQuery and SearchRank
Trigram similarity
Search configuration

✅ Elasticsearch:

Installation & setup
Document definition
Indexing data
Search implementation
Custom queries

✅ Optimization:

Database indexes
Limit results
Cache results
Defer large fields

✅ Best Practices:

Choose appropriate method
Limit searchable fields
Minimum search length
Sanitize input

Next Steps

Trong Bài 9.4, bạn sẽ học:

Pagination styles
PageNumberPagination
LimitOffsetPagination
CursorPagination
Custom pagination

Navigation:

#full-text-search

Filtering, Searching & Pagination - Phần 3 - Searching

Django Search & Filtering