Как работать с Django Q объектами для сложных запросов

 1from django.db.models import Q
 2from django.contrib.auth.models import User
 3from .models import Book, Author, Category
 4
 5# OR условие
 6books = Book.objects.filter(
 7    Q(title__icontains='django') | Q(author__name='Smith')
 8)
 9
10# AND условие (по умолчанию)
11books = Book.objects.filter(
12    Q(title__icontains='python') & Q(published=True)
13)
14
15# NOT условие
16books = Book.objects.filter(~Q(published=False))
17
18# Комбинация операций
19books = Book.objects.filter(
20    Q(title__icontains='django') | Q(author__name='Smith'),
21    Q(published=True) & Q(price__gte=100)
22)

 1# Сложные вложенные условия
 2books = Book.objects.filter(
 3    Q(
 4        Q(title__icontains='python') | Q(title__icontains='django')
 5    ) &
 6    Q(
 7        Q(author__age__gte=30) | Q(author__country='USA')
 8    ) &
 9    ~Q(category__name='Fiction')
10)
11
12# Группировка условий
13books = Book.objects.filter(
14    Q(
15        Q(title__icontains='web') | Q(title__icontains='mobile')
16    ) &
17    (
18        Q(author__experience__gte=5) | Q(author__rating__gte=4.5)
19    )
20)

 1def search_books(query, category=None, min_price=None, max_price=None):
 2    """Поиск книг по различным критериям"""
 3    q_objects = Q()
 4
 5    # Поиск по тексту в названии, описании и имени автора
 6    if query:
 7        q_objects &= (
 8            Q(title__icontains=query) |
 9            Q(description__icontains=query) |
10            Q(author__name__icontains=query) |
11            Q(author__bio__icontains=query)
12        )
13
14    # Фильтр по категории
15    if category:
16        q_objects &= Q(category__name__iexact=category)
17
18    # Фильтр по цене
19    if min_price is not None:
20        q_objects &= Q(price__gte=min_price)
21    if max_price is not None:
22        q_objects &= Q(price__lte=max_price)
23
24    return Book.objects.filter(q_objects).select_related('author', 'category')
25
26# Использование
27books = search_books(
28    query='python',
29    category='Programming',
30    min_price=50,
31    max_price=200
32)

 1def get_users_by_permissions(is_staff=None, is_active=None, groups=None):
 2  """Получение пользователей по правам и группам"""
 3  q_objects = Q()
 4
 5  if is_staff is not None:
 6      q_objects &= Q(is_staff=is_staff)
 7
 8  if is_active is not None:
 9      q_objects &= Q(is_active=is_active)
10
11  if groups:
12      if isinstance(groups, (list, tuple)):
13          # Пользователи, которые состоят в ЛЮБОЙ из указанных групп
14          group_q = Q()
15          for group in groups:
16              group_q |= Q(groups__name=group)
17          q_objects &= group_q
18      else:
19          # Пользователи, которые состоят в указанной группе
20          q_objects &= Q(groups__name=groups)
21
22  return User.objects.filter(q_objects).distinct()
23
24  # Примеры использования
25  staff_users = get_users_by_permissions(is_staff=True, is_active=True)
26  admin_users = get_users_by_permissions(groups=['Administrators', 'Moderators'])
27  active_users = get_users_by_permissions(is_active=True)

 1def find_related_books(author_name=None, category_name=None, tags=None):
 2    """Поиск книг по связанным моделям"""
 3    q_objects = Q()
 4
 5    if author_name:
 6        q_objects &= (
 7            Q(author__name__icontains=author_name) |
 8            Q(author__pseudonym__icontains=author_name)
 9        )
10
11    if category_name:
12        q_objects &= Q(category__name__iexact=category_name)
13
14    if tags:
15        if isinstance(tags, (list, tuple)):
16            # Книги, которые имеют ЛЮБОЙ из указанных тегов
17            tag_q = Q()
18            for tag in tags:
19                tag_q |= Q(tags__name__iexact=tag)
20            q_objects &= tag_q
21        else:
22            q_objects &= Q(tags__name__iexact=tags)
23
24    return Book.objects.filter(q_objects).prefetch_related(
25        'author', 'category', 'tags'
26    ).distinct()
27
28# Использование
29python_books = find_related_books(
30    category_name='Programming',
31    tags=['python', 'django', 'web']
32)

 1def build_search_query(form_data):
 2    """Построение поискового запроса на основе данных формы"""
 3    q_objects = Q()
 4
 5    # Поиск по тексту
 6    if form_data.get('search_text'):
 7        search_text = form_data['search_text']
 8        q_objects &= (
 9            Q(title__icontains=search_text) |
10            Q(description__icontains=search_text) |
11            Q(author__name__icontains=search_text)
12        )
13
14    # Фильтр по статусу
15    status = form_data.get('status')
16    if status and status != 'all':
17        q_objects &= Q(status=status)
18
19    # Фильтр по дате публикации
20    date_from = form_data.get('date_from')
21    date_to = form_data.get('date_to')
22
23    if date_from:
24        q_objects &= Q(published_at__gte=date_from)
25    if date_to:
26        q_objects &= Q(published_at__lte=date_to)
27
28    # Фильтр по рейтингу
29    min_rating = form_data.get('min_rating')
30    if min_rating:
31        q_objects &= Q(rating__gte=float(min_rating))
32
33    return q_objects
34
35# В view
36def book_search(request):
37    form = BookSearchForm(request.GET)
38    if form.is_valid():
39        q_objects = build_search_query(form.cleaned_data)
40        books = Book.objects.filter(q_objects).select_related('author')
41    else:
42        books = Book.objects.none()
43
44    return render(request, 'books/search.html', {
45        'books': books,
46        'form': form
47    })

 1def build_api_filters(filter_params):
 2    """Построение фильтров для API на основе параметров запроса"""
 3    q_objects = Q()
 4
 5    # Маппинг параметров на поля модели
 6    field_mapping = {
 7        'title': 'title__icontains',
 8        'author': 'author__name__icontains',
 9        'category': 'category__name__iexact',
10        'status': 'status__iexact',
11        'min_price': 'price__gte',
12        'max_price': 'price__lte',
13        'min_rating': 'rating__gte',
14        'max_rating': 'rating__lte',
15        'published_after': 'published_at__gte',
16        'published_before': 'published_at__lte',
17    }
18
19    for param, value in filter_params.items():
20        if param in field_mapping and value:
21            field_name = field_mapping[param]
22
23            # Обработка специальных случаев
24            if param in ['min_price', 'max_price', 'min_rating', 'max_rating']:
25                try:
26                    value = float(value)
27                except (ValueError, TypeError):
28                    continue
29
30            elif param in ['published_after', 'published_before']:
31                try:
32                    from datetime import datetime
33                    value = datetime.fromisoformat(value)
34                except ValueError:
35                    continue
36
37            # Добавляем условие
38            q_objects &= Q(**{field_name: value})
39
40    return q_objects
41
42# В API view
43class BookListAPIView(ListAPIView):
44    serializer_class = BookSerializer
45    queryset = Book.objects.all()
46
47    def get_queryset(self):
48        queryset = super().get_queryset()
49
50        # Получаем параметры фильтрации
51        filter_params = self.request.query_params.dict()
52
53        # Убираем параметры пагинации
54        filter_params.pop('page', None)
55        filter_params.pop('page_size', None)
56
57        if filter_params:
58            q_objects = build_api_filters(filter_params)
59            queryset = queryset.filter(q_objects)
60
61        return queryset.select_related('author', 'category')

 1# Без оптимизации - N+1 проблема
 2books = Book.objects.filter(
 3    Q(title__icontains='python') | Q(author__name__icontains='Smith')
 4)
 5
 6# С оптимизацией - один запрос для связанных данных
 7books = Book.objects.filter(
 8    Q(title__icontains='python') | Q(author__name__icontains='Smith')
 9).select_related('author', 'category').prefetch_related('tags')
10
11# Для ManyToMany отношений
12books = Book.objects.filter(
13    Q(tags__name__in=['python', 'django']) | Q(category__name='Programming')
14).prefetch_related('tags', 'category').distinct()

1# Выбираем только нужные поля
2books = Book.objects.filter(
3    Q(title__icontains='python') | Q(author__name__icontains='Smith')
4).only('id', 'title', 'author__name', 'price')
5
6# Исключаем тяжелые поля
7books = Book.objects.filter(
8    Q(content__icontains='django') | Q(description__icontains='web')
9).defer('content', 'full_text', 'metadata')

 1# Получаем только значения полей (словари)
 2books_data = Book.objects.filter(
 3    Q(title__icontains='python') | Q(author__name__icontains='Smith')
 4).values('id', 'title', 'author__name', 'price')
 5
 6# Получаем кортежи значений
 7books_tuples = Book.objects.filter(
 8    Q(title__icontains='python') | Q(author__name__icontains='Smith')
 9).values_list('id', 'title', 'author__name', 'price')
10
11# Плоский список значений
12book_titles = Book.objects.filter(
13    Q(title__icontains='python') | Q(author__name__icontains='Smith')
14).values_list('title', flat=True)

 1from django.db.models import Case, When, Value, IntegerField
 2
 3def search_books_with_relevance(query):
 4    """Поиск книг с учетом релевантности"""
 5    if not query:
 6        return Book.objects.none()
 7
 8    # Создаем Q объекты для разных типов поиска
 9    title_match = Q(title__icontains=query)
10    author_match = Q(author__name__icontains=query)
11    description_match = Q(description__icontains=query)
12    content_match = Q(content__icontains=query)
13
14    # Комбинируем условия
15    q_objects = title_match | author_match | description_match | content_match
16
17    # Добавляем веса для релевантности
18    books = Book.objects.filter(q_objects).annotate(
19        relevance=Case(
20            When(title__icontains=query, then=Value(100)),  # Высший приоритет
21            When(author__name__icontains=query, then=Value(80)),
22            When(description__icontains=query, then=Value(60)),
23            When(content__icontains=query, then=Value(40)),
24            default=Value(0),
25            output_field=IntegerField(),
26        )
27    ).order_by('-relevance', '-rating')
28
29    return books
30
31# Использование
32relevant_books = search_books_with_relevance('python django')

 1from django.contrib.gis.geos import Point
 2from django.contrib.gis.db.models.functions import Distance
 3
 4def find_nearby_stores(latitude, longitude, radius_km=10):
 5    """Поиск магазинов в радиусе от указанной точки"""
 6    user_location = Point(longitude, latitude, srid=4326)
 7
 8    q_objects = Q(
 9        Q(is_active=True) & Q(has_delivery=True)
10    )
11
12    stores = Store.objects.filter(q_objects).annotate(
13        distance=Distance('location', user_location)
14    ).filter(
15        distance__lte=radius_km * 1000  # Конвертируем в метры
16    ).order_by('distance')
17
18    return stores
19
20# Использование
21nearby_stores = find_nearby_stores(55.7558, 37.6176, radius_km=5)

 1from datetime import datetime, timedelta
 2from django.utils import timezone
 3
 4def find_available_slots(service_id, date, duration_hours=1):
 5    """Поиск доступных временных слотов для записи"""
 6    start_date = timezone.make_aware(datetime.combine(date, datetime.min.time()))
 7    end_date = start_date + timedelta(days=1)
 8
 9    # Получаем занятые слоты
10    booked_slots = Appointment.objects.filter(
11        Q(service_id=service_id) &
12        Q(
13            Q(start_time__lt=end_date) & Q(end_time__gt=start_date)
14        )
15    ).values_list('start_time', 'end_time')
16
17    # Создаем Q объект для исключения занятых слотов
18    exclude_q = Q()
19    for start, end in booked_slots:
20        exclude_q |= Q(
21            Q(start_time__lt=end) & Q(end_time__gt=start)
22        )
23
24    # Ищем доступные слоты
25    available_slots = TimeSlot.objects.filter(
26        Q(service_id=service_id) &
27        Q(start_time__gte=start_date) &
28        Q(start_time__lt=end_date) &
29        Q(duration_hours=duration_hours)
30    ).exclude(exclude_q)
31
32    return available_slots

 1# tests.py
 2from django.test import TestCase
 3from django.db.models import Q
 4from .models import Book, Author, Category
 5
 6class QObjectsTestCase(TestCase):
 7    def setUp(self):
 8        # Создаем тестовые данные
 9        self.author = Author.objects.create(
10            name='John Smith',
11            age=35,
12            country='USA'
13        )
14
15        self.category = Category.objects.create(name='Programming')
16
17        self.book = Book.objects.create(
18            title='Python Programming',
19            author=self.author,
20            category=self.category,
21            price=100,
22            published=True
23        )
24
25    def test_or_condition(self):
26        """Тестирование OR условия"""
27        books = Book.objects.filter(
28            Q(title__icontains='python') | Q(author__name='John Smith')
29        )
30        self.assertEqual(books.count(), 1)
31        self.assertEqual(books.first(), self.book)
32
33    def test_and_condition(self):
34        """Тестирование AND условия"""
35        books = Book.objects.filter(
36            Q(title__icontains='python') & Q(price__gte=50)
37        )
38        self.assertEqual(books.count(), 1)
39        self.assertEqual(books.first(), self.book)
40
41    def test_not_condition(self):
42        """Тестирование NOT условия"""
43        books = Book.objects.filter(~Q(published=False))
44        self.assertEqual(books.count(), 1)
45        self.assertEqual(books.first(), self.book)
46
47    def test_complex_query(self):
48        """Тестирование сложного запроса"""
49        books = Book.objects.filter(
50            Q(
51                Q(title__icontains='python') | Q(title__icontains='django')
52            ) &
53            Q(author__age__gte=30) &
54            Q(category__name='Programming')
55        )
56        self.assertEqual(books.count(), 1)
57        self.assertEqual(books.first(), self.book)

 1import logging
 2from django.db import connection
 3
 4logger = logging.getLogger('django.db.backends')
 5
 6def debug_query(queryset):
 7    """Отладка SQL запроса"""
 8    # Включаем логирование SQL
 9    logging.getLogger('django.db.backends').setLevel(logging.DEBUG)
10
11    # Выполняем запрос
12    result = list(queryset)
13
14    # Получаем SQL запрос
15    sql_query = queryset.query
16
17    # Логируем информацию
18    logger.info(f"SQL Query: {sql_query}")
19    logger.info(f"Number of queries: {len(connection.queries)}")
20
21    return result
22
23# Использование
24books = Book.objects.filter(
25    Q(title__icontains='python') | Q(author__name__icontains='Smith')
26)
27debug_query(books)

 1import time
 2from django.db import connection
 3
 4def profile_query(queryset, description="Query"):
 5    """Профилирование производительности запроса"""
 6    start_time = time.time()
 7
 8    # Сбрасываем счетчик запросов
 9    initial_queries = len(connection.queries)
10
11    # Выполняем запрос
12    result = list(queryset)
13
14    # Вычисляем метрики
15    execution_time = time.time() - start_time
16    queries_count = len(connection.queries) - initial_queries
17
18    print(f"{description}:")
19    print(f"  Execution time: {execution_time:.4f} seconds")
20    print(f"  Number of queries: {queries_count}")
21    print(f"  Result count: {len(result)}")
22
23    return result
24
25# Использование
26books = Book.objects.filter(
27    Q(title__icontains='python') | Q(author__name__icontains='Smith')
28)
29profile_query(books, "Book search with Q objects")