Django Query Subclassing Issue

Based on the information provided, you're encountering an issue with your custom Query subclass when using exclude() with subqueries in Django 4.1, which worked fine in Django 3.2.

The Problem

The issue appears to be in your get_compiler method implementation. When you:

1. Clone the query
2. Add a filter to the cloned query
3. Pass the cloned query to super().get_compiler

This approach worked in Django 3.2 but breaks in Django 4.1, particularly with exclude() queries containing subqueries.

Recommended Solution

Instead of modifying the query in get_compiler, consider using Django's built-in filtering mechanisms. Here are a few approaches:

1. Use a Custom Manager

PYTHONCopied
from django.db import models
from django.db.models.query import QuerySet

class SchoolQuerySet(QuerySet):
    def get_queryset(self):
        return super().get_queryset().filter(school_id=1)

class SchoolManager(models.Manager):
    def get_queryset(self):
        return SchoolQuerySet(self.model, using=self._db).filter(school_id=1)

class YourModel(models.Model):
    # fields...
    objects = SchoolManager()

2. Use Query Middleware

Instead of directly subclassing Query, consider implementing a custom middleware that modifies the queryset before execution:

PYTHONCopied
from django.db import models
from django.db.models.query import QuerySet

class SchoolFilterQuerySet(QuerySet):
    def _filter_by_school(self, qs):
        return qs.filter(school_id=1)
    
    def _clone(self):
        clone = super()._clone()
        return clone
    
    def iterator(self, chunk_size=None):
        # Apply the school filter just before execution
        filtered_qs = self._filter_by_school(self)
        return super(SchoolFilterQuerySet, filtered_qs).iterator(chunk_size=chunk_size)

3. Fix Your Current Implementation

If you must keep your current approach, the issue might be in how you're passing the cloned query to super():

PYTHONCopied
class SchoolQuery(sql.Query):
    def get_compiler(self, using=None, connection=None, elide_empty=True):
        # Clone the query
        q = self.clone()
        # Add your filter
        q_expr = Q(school_id=1)
        q.add_q(q_expr)
        
        # The issue might be here - you're passing 'q' as the second argument
        # which is incorrect for super() calls
        return super().get_compiler(
            using=using, connection=connection, elide_empty=elide_empty
        )

The correct way would be:

PYTHONCopied
class SchoolQuery(sql.Query):
    def get_compiler(self, using=None, connection=None, elide_empty=True):
        # Clone the query
        self.add_q(Q(school_id=1))
        # Let the normal compiler handle it
        return super().get_compiler(
            using=using, connection=connection, elide_empty=elide_empty
        )

Remember that Django's QuerySets are designed to be immutable - each refinement creates a new QuerySet. Your approach of modifying the query in get_compiler might be working against Django's design principles, which could explain why it broke in a newer version.

Consider using Django's built-in filtering mechanisms rather than low-level query manipulation for better compatibility with future Django versions.