如何在Django+PostgreSQL中实现支持逻辑运算符的不区分大小写前缀搜索？

基于Django、Django REST Framework（DRF）和PostgreSQL开发项目，需实现满足以下条件的搜索功能：

• 支持AND、OR、NOT逻辑运算符
• 不区分大小写
• 支持*前缀匹配（如som*可匹配some、somali等）

最初尝试使用Postgres全文搜索的search_type='websearch'类型，但该类型不支持*运算符，因此切换为raw类型搜索，当前搜索类代码如下：

class DataSearch(generics.ListAPIView):
    serializer_class = DataSerializer
    
    def get_queryset(self):
        q = self.request.query_params.get('query')
        
        if q:
            vector = SearchVector('research', 'data', 'research__name')
            query = SearchQuery(q, search_type='raw')
            queryset = Data.objects.annotate(search=vector).filter(search=query)
        else:
            queryset = Data.objects.none()
        return queryset

当前方案已实现逻辑运算符和*前缀匹配功能，但无法实现不区分大小写，需解决该问题或提供其他可行方案。

方法一：调整全文搜索配置实现大小写不敏感 #

PostgreSQL全文搜索的大小写敏感性取决于文本处理配置，针对raw类型搜索，可通过两种方式实现大小写不敏感：

1. 统一字段与查询的大小写 #

创建SearchVector时对字段做小写转换，同时将用户输入的查询字符串转为小写，确保匹配时不区分大小写：

from django.db.models import Func, F

class DataSearch(generics.ListAPIView):
    serializer_class = DataSerializer
    
    def get_queryset(self):
        q = self.request.query_params.get('query')
        
        if q:
            # 保留*前缀格式的同时将查询转为小写
            lower_query = q.lower()
            # 对目标字段做小写处理后生成搜索向量
            search_vector = SearchVector(
                Func(F('research'), function='LOWER'),
                Func(F('data'), function='LOWER'),
                Func(F('research__name'), function='LOWER'),
                config='english'
            )
            search_query = SearchQuery(lower_query, search_type='raw', config='english')
            queryset = Data.objects.annotate(search=search_vector).filter(search=search_query)
        else:
            queryset = Data.objects.none()
        return queryset

2. 创建PostgreSQL自定义大小写不敏感搜索配置 #

在PostgreSQL中创建忽略大小写的文本搜索配置，让全文搜索默认处理为小写：

-- 基于english字典创建大小写不敏感配置
CREATE TEXT SEARCH CONFIGURATION english_ci (COPY = english);
ALTER TEXT SEARCH CONFIGURATION english_ci
    ALTER MAPPING FOR hword, hword_part, word
    WITH english_stem, lower;

之后在Django代码中指定该配置：

class DataSearch(generics.ListAPIView):
    serializer_class = DataSerializer
    
    def get_queryset(self):
        q = self.request.query_params.get('query')
        
        if q:
            lower_query = q.lower()
            search_vector = SearchVector(
                'research', 'data', 'research__name',
                config='english_ci'
            )
            search_query = SearchQuery(lower_query, search_type='raw', config='english_ci')
            queryset = Data.objects.annotate(search=search_vector).filter(search=search_query)
        else:
            queryset = Data.objects.none()
        return queryset

这种方式更彻底，所有文本会被自动转为小写进行索引和匹配。

方法二：结合Q对象与icontains（小数据集适用） #

如果数据量不大，可以放弃全文搜索，直接用Django的Q对象结合icontains实现需求，同时解析逻辑运算符：

from django.db.models import Q
import re

class DataSearch(generics.ListAPIView):
    serializer_class = DataSerializer
    
    def get_queryset(self):
        q = self.request.query_params.get('query')
        
        if q:
            lower_q = q.lower()
            # 拆分查询中的逻辑运算符和关键词
            terms = re.split(r'\s+(AND|OR|NOT)\s+', lower_q, flags=re.IGNORECASE)
            q_obj = Q()
            current_op = 'AND'
            
            for part in terms:
                part = part.strip()
                if part.upper() in ['AND', 'OR', 'NOT']:
                    current_op = part.upper()
                    continue
                # 处理前缀匹配：将som*转为匹配以som开头的字符串
                if part.endswith('*'):
                    term = part[:-1]
                    field_q = Q(research__istartswith=term) | Q(data__istartswith=term) | Q(research__name__istartswith=term)
                else:
                    term = part
                    field_q = Q(research__icontains=term) | Q(data__icontains=term) | Q(research__name__icontains=term)
                
                # 应用逻辑运算符
                if current_op == 'AND':
                    q_obj &= field_q
                elif current_op == 'OR':
                    q_obj |= field_q
                elif current_op == 'NOT':
                    q_obj &= ~field_q
            
            queryset = Data.objects.filter(q_obj)
        else:
            queryset = Data.objects.none()
        return queryset

注意：该方法在大数据集上性能较差，无法利用全文索引，仅适合数据量小的场景。

方法三：使用PostgreSQL Trigram搜索（模糊匹配友好） #

启用PostgreSQL的pg_trgm扩展，支持基于 trigram 的模糊搜索，天然支持不区分大小写，还能通过索引提升性能：

1. 先在PostgreSQL中启用扩展：

   CREATE EXTENSION pg_trgm;
   

2. 创建索引优化查询速度：

   CREATE INDEX idx_data_research_trgm ON data USING GIN (research gin_trgm_ops);
   CREATE INDEX idx_data_data_trgm ON data USING GIN (data gin_trgm_ops);
   CREATE INDEX idx_research_name_trgm ON research USING GIN (name gin_trgm_ops);
   

3. Django代码实现：

   from django.db.models import Q
   
   

class DataSearch(generics.ListAPIView):
serializer_class = DataSerializer

def get_queryset(self):
    q = self.request.query_params.get('query')
    
    if q:
        lower_q = q.lower()
        q_obj = Q()
        
        # 处理前缀匹配
        if lower_q.endswith('*'):
            prefix = lower_q[:-1]
            q_obj = Q(research__istartswith=prefix) | Q(data__istartswith=prefix) | Q(research__name__istartswith=prefix)
        else:
            # 普通模糊匹配
            q_obj = Q(research__icontains=lower_q) | Q(data__icontains=lower_q) | Q(research__name__icontains=lower_q)
        
        # 可参考方法二扩展逻辑运算符解析
        # ...
        
        queryset = Data.objects.filter(q_obj)
    else:
        queryset = Data.objects.none()
    return queryset

---

> 内容的提问来源于stack exchange，提问作者Iggy Comdore