django-cte 1.3.3.dev20250530125340__tar.gz → 2.0.0.dev20250610173146__tar.gz

{django_cte-1.3.3.dev20250530125340 → django_cte-2.0.0.dev20250610173146}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-cte
-Version: 1.3.3.dev20250530125340
+Version: 2.0.0.dev20250610173146
 Summary: Common Table Expressions (CTE) for Django
 Author-email: Daniel Miller <millerdev@gmail.com>
 Requires-Python: >= 3.9

django_cte-2.0.0.dev20250610173146/django_cte/__init__.py

@@ -0,0 +1,4 @@
+from .cte import CTE, with_cte, CTEManager, CTEQuerySet, With  # noqa
+
+__version__ = "2.0.0.dev20250610173146"
+__all__ = ["CTE", "with_cte"]

django_cte-2.0.0.dev20250610173146/django_cte/_deprecated.py

@@ -0,0 +1,138 @@
+try:
+    from warnings import deprecated
+except ImportError:
+    from warnings import warn
+
+    # Copied from Python 3.13, lightly modified for Python 3.9 compatibility.
+    # Can be removed when the oldest supported Python version is 3.13.
+    class deprecated:
+        """Indicate that a class, function or overload is deprecated.
+
+        When this decorator is applied to an object, the type checker
+        will generate a diagnostic on usage of the deprecated object.
+
+        Usage:
+
+            @deprecated("Use B instead")
+            class A:
+                pass
+
+            @deprecated("Use g instead")
+            def f():
+                pass
+
+            @overload
+            @deprecated("int support is deprecated")
+            def g(x: int) -> int: ...
+            @overload
+            def g(x: str) -> int: ...
+
+        The warning specified by *category* will be emitted at runtime
+        on use of deprecated objects. For functions, that happens on calls;
+        for classes, on instantiation and on creation of subclasses.
+        If the *category* is ``None``, no warning is emitted at runtime.
+        The *stacklevel* determines where the
+        warning is emitted. If it is ``1`` (the default), the warning
+        is emitted at the direct caller of the deprecated object; if it
+        is higher, it is emitted further up the stack.
+        Static type checker behavior is not affected by the *category*
+        and *stacklevel* arguments.
+
+        The deprecation message passed to the decorator is saved in the
+        ``__deprecated__`` attribute on the decorated object.
+        If applied to an overload, the decorator
+        must be after the ``@overload`` decorator for the attribute to
+        exist on the overload as returned by ``get_overloads()``.
+
+        See PEP 702 for details.
+
+        """
+        def __init__(
+            self,
+            message: str,
+            /,
+            *,
+            category=DeprecationWarning,
+            stacklevel=1,
+        ):
+            if not isinstance(message, str):
+                raise TypeError(
+                    f"Expected an object of type str for 'message', not {type(message).__name__!r}"
+                )
+            self.message = message
+            self.category = category
+            self.stacklevel = stacklevel
+
+        def __call__(self, arg, /):
+            # Make sure the inner functions created below don't
+            # retain a reference to self.
+            msg = self.message
+            category = self.category
+            stacklevel = self.stacklevel
+            if category is None:
+                arg.__deprecated__ = msg
+                return arg
+            elif isinstance(arg, type):
+                import functools
+                from types import MethodType
+
+                original_new = arg.__new__
+
+                @functools.wraps(original_new)
+                def __new__(cls, /, *args, **kwargs):
+                    if cls is arg:
+                        warn(msg, category=category, stacklevel=stacklevel + 1)
+                    if original_new is not object.__new__:
+                        return original_new(cls, *args, **kwargs)
+                    # Mirrors a similar check in object.__new__.
+                    elif cls.__init__ is object.__init__ and (args or kwargs):
+                        raise TypeError(f"{cls.__name__}() takes no arguments")
+                    else:
+                        return original_new(cls)
+
+                arg.__new__ = staticmethod(__new__)
+
+                original_init_subclass = arg.__init_subclass__
+                # We need slightly different behavior if __init_subclass__
+                # is a bound method (likely if it was implemented in Python)
+                if isinstance(original_init_subclass, MethodType):
+                    original_init_subclass = original_init_subclass.__func__
+
+                    @functools.wraps(original_init_subclass)
+                    def __init_subclass__(*args, **kwargs):
+                        warn(msg, category=category, stacklevel=stacklevel + 1)
+                        return original_init_subclass(*args, **kwargs)
+
+                    arg.__init_subclass__ = classmethod(__init_subclass__)
+                # Or otherwise, which likely means it's a builtin such as
+                # object's implementation of __init_subclass__.
+                else:
+                    @functools.wraps(original_init_subclass)
+                    def __init_subclass__(*args, **kwargs):
+                        warn(msg, category=category, stacklevel=stacklevel + 1)
+                        return original_init_subclass(*args, **kwargs)
+
+                    arg.__init_subclass__ = __init_subclass__
+
+                arg.__deprecated__ = __new__.__deprecated__ = msg
+                __init_subclass__.__deprecated__ = msg
+                return arg
+            elif callable(arg):
+                import functools
+                import inspect
+
+                @functools.wraps(arg)
+                def wrapper(*args, **kwargs):
+                    warn(msg, category=category, stacklevel=stacklevel + 1)
+                    return arg(*args, **kwargs)
+
+                if inspect.iscoroutinefunction(arg):
+                    wrapper = inspect.markcoroutinefunction(wrapper)
+
+                arg.__deprecated__ = wrapper.__deprecated__ = msg
+                return wrapper
+            else:
+                raise TypeError(
+                    "@deprecated decorator with non-None category must be applied to "
+                    f"a class or callable, not {arg!r}"
+                )

{django_cte-1.3.3.dev20250530125340 → django_cte-2.0.0.dev20250610173146}/django_cte/cte.py

@@ -1,17 +1,38 @@
-from django.db.models import Manager
+from copy import copy
+
+from django.db.models import Manager, sql
 from django.db.models.expressions import Ref
 from django.db.models.query import Q, QuerySet, ValuesIterable
 from django.db.models.sql.datastructures import BaseTable
 
+from .jitmixin import jit_mixin
 from .join import QJoin, INNER
 from .meta import CTEColumnRef, CTEColumns
 from .query import CTEQuery
+from ._deprecated import deprecated
+
+__all__ = ["CTE", "with_cte"]
+
+
+def with_cte(*ctes, select):
+    """Add Common Table Expression(s) (CTEs) to a model or queryset
 
-__all__ = ["With", "CTEManager", "CTEQuerySet"]
+    :param *ctes: One or more CTE objects.
+    :param select: A model class, queryset, or CTE to use as the base
+        query to which CTEs are attached.
+    :returns: A queryset with the given CTE added to it.
+    """
+    if isinstance(select, CTE):
+        select = select.queryset()
+    elif not isinstance(select, QuerySet):
+        select = select._default_manager.all()
+    jit_mixin(select.query, CTEQuery)
+    select.query._with_ctes += ctes
+    return select
 
 
-class With(object):
-    """Common Table Expression query object: `WITH ...`
+class CTE:
+    """Common Table Expression
 
     :param queryset: A queryset to use as the body of the CTE.
     :param name: Optional name parameter for the CTE (default: "cte").
@@ -41,7 +62,7 @@ class With(object):
 
     @classmethod
     def recursive(cls, make_cte_queryset, name="cte", materialized=False):
-        """Recursive Common Table Expression: `WITH RECURSIVE ...`
+        """Recursive Common Table Expression
 
         :param make_cte_queryset: Function taking a single argument (a
         not-yet-fully-constructed cte object) and returning a `QuerySet`
@@ -58,10 +79,11 @@ class With(object):
     def join(self, model_or_queryset, *filter_q, **filter_kw):
         """Join this CTE to the given model or queryset
 
-        This CTE will be refernced by the returned queryset, but the
+        This CTE will be referenced by the returned queryset, but the
+
         corresponding `WITH ...` statement will not be prepended to the
-        queryset's SQL output; use `<CTEQuerySet>.with_cte(cte)` to
-        achieve that outcome.
+        queryset's SQL output; use `with_cte(cte, select=cte.join(...))`
+        to achieve that outcome.
 
         :param model_or_queryset: Model class or queryset to which the
         CTE should be joined.
@@ -96,15 +118,15 @@ class With(object):
 
         This CTE will be referenced by the returned queryset, but the
         corresponding `WITH ...` statement will not be prepended to the
-        queryset's SQL output; use `<CTEQuerySet>.with_cte(cte)` to
-        achieve that outcome.
+        queryset's SQL output; use `with_cte(cte, select=cte)` to do
+        that.
 
         :returns: A queryset.
         """
         cte_query = self.query
         qs = cte_query.model._default_manager.get_queryset()
 
-        query = CTEQuery(cte_query.model)
+        query = jit_mixin(sql.Query(cte_query.model), CTEQuery)
         query.join(BaseTable(self.name, None))
         query.default_cols = cte_query.default_cols
         query.deferred_loading = cte_query.deferred_loading
@@ -113,8 +135,7 @@ class With(object):
             qs._iterable_class = ValuesIterable
         for alias in getattr(cte_query, "selected", None) or ():
             if alias not in cte_query.annotations:
-                field = cte_query.resolve_ref(alias).output_field
-                col = CTEColumnRef(alias, self.name, field)
+                col = Ref(alias, cte_query.resolve_ref(alias))
                 query.add_annotation(col, alias)
         if cte_query.annotations:
             for alias, value in cte_query.annotations.items():
@@ -128,29 +149,41 @@ class With(object):
     def _resolve_ref(self, name):
         selected = getattr(self.query, "selected", None)
         if selected and name in selected and name not in self.query.annotations:
-            return Ref(name, self.query)
+            return Ref(name, self.query.resolve_ref(name))
         return self.query.resolve_ref(name)
 
+    def resolve_expression(self, *args, **kw):
+        if self.query is None:
+            raise ValueError("Cannot resolve recursive CTE without a query.")
+        clone = copy(self)
+        clone.query = clone.query.resolve_expression(*args, **kw)
+        return clone
+
+
+@deprecated("Use `django_cte.CTE` instead.")
+class With(CTE):
+
+    @staticmethod
+    @deprecated("Use `django_cte.CTE.recursive` instead.")
+    def recursive(*args, **kw):
+        return CTE.recursive(*args, **kw)
+
 
+@deprecated("CTEQuerySet is deprecated. "
+            "CTEs can now be applied to any queryset using `with_cte()`")
 class CTEQuerySet(QuerySet):
     """QuerySet with support for Common Table Expressions"""
 
     def __init__(self, model=None, query=None, using=None, hints=None):
         # Only create an instance of a Query if this is the first invocation in
         # a query chain.
-        if query is None:
-            query = CTEQuery(model)
         super(CTEQuerySet, self).__init__(model, query, using, hints)
+        jit_mixin(self.query, CTEQuery)
 
+    @deprecated("Use `django_cte.with_cte(cte, select=...)` instead.")
     def with_cte(self, cte):
-        """Add a Common Table Expression to this queryset
-
-        The CTE `WITH ...` clause will be added to the queryset's SQL
-        output (after other CTEs that have already been added) so it
-        can be referenced in annotations, filters, etc.
-        """
         qs = self._clone()
-        qs.query._with_ctes.append(cte)
+        qs.query._with_ctes += cte,
         return qs
 
     def as_manager(cls):
@@ -162,36 +195,9 @@ class CTEQuerySet(QuerySet):
     as_manager.queryset_only = True
     as_manager = classmethod(as_manager)
 
-    def _combinator_query(self, *args, **kw):
-        clone = super()._combinator_query(*args, **kw)
-        if clone.query.combinator:
-            ctes = clone.query._with_ctes = []
-            seen = {}
-            for query in clone.query.combined_queries:
-                for cte in getattr(query, "_with_ctes", []):
-                    if seen.get(cte.name) is cte:
-                        continue
-                    if cte.name in seen:
-                        raise ValueError(
-                            f"Found two or more CTEs named '{cte.name}'. "
-                            "Hint: assign a unique name to each CTE."
-                        )
-                    ctes.append(cte)
-                    seen[cte.name] = cte
-            if ctes:
-                def without_ctes(query):
-                    if getattr(query, "_with_ctes", None):
-                        query = query.clone()
-                        query._with_ctes = []
-                    return query
-
-                clone.query.combined_queries = [
-                    without_ctes(query)
-                    for query in clone.query.combined_queries
-                ]
-        return clone
-
 
+@deprecated("CTEMAnager is deprecated. "
+            "CTEs can now be applied to any queryset using `with_cte()`")
 class CTEManager(Manager.from_queryset(CTEQuerySet)):
     """Manager for models that perform CTE queries"""
 

django_cte-2.0.0.dev20250610173146/django_cte/jitmixin.py

@@ -0,0 +1,28 @@
+def jit_mixin(obj, mixin):
+    """Apply mixin to object and return the object"""
+    if not isinstance(obj, mixin):
+        obj.__class__ = jit_mixin_type(obj.__class__, mixin)
+    return obj
+
+
+def jit_mixin_type(base, *mixins):
+    assert not issubclass(base, mixins), (base, mixins)
+    mixed = _mixin_cache.get((base, mixins))
+    if mixed is None:
+        prefix = "".join(m._jit_mixin_prefix for m in mixins)
+        name = f"{prefix}{base.__name__}"
+        mixed = _mixin_cache[(base, mixins)] = type(name, (*mixins, base), {
+            "_jit_mixin_base": getattr(base, "_jit_mixin_base", base),
+            "_jit_mixins": mixins + getattr(base, "_jit_mixins", ()),
+        })
+    return mixed
+
+
+_mixin_cache = {}
+
+
+class JITMixin:
+
+    def __reduce__(self):
+        # make JITMixin classes pickleable
+        return (jit_mixin_type, (self._jit_mixin_base, *self._jit_mixins))

{django_cte-1.3.3.dev20250530125340 → django_cte-2.0.0.dev20250610173146}/django_cte/join.py

@@ -1,7 +1,7 @@
 from django.db.models.sql.constants import INNER
 
 
-class QJoin(object):
+class QJoin:
     """Join clause with join condition from Q object clause
 
     :param parent_alias: Alias of parent table.

{django_cte-1.3.3.dev20250530125340 → django_cte-2.0.0.dev20250610173146}/django_cte/meta.py

@@ -3,7 +3,7 @@ import weakref
 from django.db.models.expressions import Col, Expression
 
 
-class CTEColumns(object):
+class CTEColumns:
 
     def __init__(self, cte):
         self._cte = weakref.ref(cte)
@@ -87,7 +87,7 @@ class CTEColumnRef(Expression):
             clone._alias = self._alias or query.table_map.get(
                 self.cte_name, [self.cte_name])[0]
             return clone
-        return super(CTEColumnRef, self).resolve_expression(
+        return super().resolve_expression(
             query, allow_joins, reuse, summarize, for_save)
 
     def relabeled_clone(self, change_map):
@@ -95,7 +95,7 @@ class CTEColumnRef(Expression):
             self.cte_name not in change_map
             and self._alias not in change_map
         ):
-            return super(CTEColumnRef, self).relabeled_clone(change_map)
+            return super().relabeled_clone(change_map)
 
         clone = self.copy()
         if self.cte_name in change_map:

django_cte-2.0.0.dev20250610173146/django_cte/query.py

@@ -0,0 +1,168 @@
+import django
+from django.core.exceptions import EmptyResultSet
+from django.db.models.sql.constants import LOUTER
+
+from .jitmixin import JITMixin, jit_mixin
+from .join import QJoin
+
+# NOTE: it is currently not possible to execute delete queries that
+# reference CTEs without patching `QuerySet.delete` (Django method)
+# to call `self.query.chain(sql.DeleteQuery)` instead of
+# `sql.DeleteQuery(self.model)`
+
+
+class CTEQuery(JITMixin):
+    """A Query mixin that processes SQL compilation through a CTE compiler"""
+    _jit_mixin_prefix = "CTE"
+    _with_ctes = ()
+
+    @property
+    def combined_queries(self):
+        return self.__dict__.get("combined_queries", ())
+
+    @combined_queries.setter
+    def combined_queries(self, queries):
+        ctes = []
+        seen = {cte.name: cte for cte in self._with_ctes}
+        for query in queries:
+            for cte in getattr(query, "_with_ctes", ()):
+                if seen.get(cte.name) is cte:
+                    continue
+                if cte.name in seen:
+                    raise ValueError(
+                        f"Found two or more CTEs named '{cte.name}'. "
+                        "Hint: assign a unique name to each CTE."
+                    )
+                ctes.append(cte)
+                seen[cte.name] = cte
+
+        if seen:
+            def without_ctes(query):
+                if getattr(query, "_with_ctes", None):
+                    query = query.clone()
+                    del query._with_ctes
+                return query
+
+            self._with_ctes += tuple(ctes)
+            queries = tuple(without_ctes(q) for q in queries)
+        self.__dict__["combined_queries"] = queries
+
+    def resolve_expression(self, *args, **kwargs):
+        clone = super().resolve_expression(*args, **kwargs)
+        clone._with_ctes = tuple(
+            cte.resolve_expression(*args, **kwargs)
+            for cte in clone._with_ctes
+        )
+        return clone
+
+    def get_compiler(self, *args, **kwargs):
+        return jit_mixin(super().get_compiler(*args, **kwargs), CTECompiler)
+
+    def chain(self, klass=None):
+        clone = jit_mixin(super().chain(klass), CTEQuery)
+        clone._with_ctes = self._with_ctes
+        return clone
+
+
+def generate_cte_sql(connection, query, as_sql):
+    if not query._with_ctes:
+        return as_sql()
+
+    ctes = []
+    params = []
+    for cte in query._with_ctes:
+        if django.VERSION > (4, 2):
+            _ignore_with_col_aliases(cte.query)
+
+        alias = query.alias_map.get(cte.name)
+        should_elide_empty = (
+                not isinstance(alias, QJoin) or alias.join_type != LOUTER
+        )
+
+        compiler = cte.query.get_compiler(
+            connection=connection, elide_empty=should_elide_empty
+        )
+
+        qn = compiler.quote_name_unless_alias
+        try:
+            cte_sql, cte_params = compiler.as_sql()
+        except EmptyResultSet:
+            # If the CTE raises an EmptyResultSet the SqlCompiler still
+            # needs to know the information about this base compiler
+            # like, col_count and klass_info.
+            as_sql()
+            raise
+        template = get_cte_query_template(cte)
+        ctes.append(template.format(name=qn(cte.name), query=cte_sql))
+        params.extend(cte_params)
+
+    explain_attribute = "explain_info"
+    explain_info = getattr(query, explain_attribute, None)
+    explain_format = getattr(explain_info, "format", None)
+    explain_options = getattr(explain_info, "options", {})
+
+    explain_query_or_info = getattr(query, explain_attribute, None)
+    sql = []
+    if explain_query_or_info:
+        sql.append(
+            connection.ops.explain_query_prefix(
+                explain_format,
+                **explain_options
+            )
+        )
+        # this needs to get set to None so that the base as_sql() doesn't
+        # insert the EXPLAIN statement where it would end up between the
+        # WITH ... clause and the final SELECT
+        setattr(query, explain_attribute, None)
+
+    if ctes:
+        # Always use WITH RECURSIVE
+        # https://www.postgresql.org/message-id/13122.1339829536%40sss.pgh.pa.us
+        sql.extend(["WITH RECURSIVE", ", ".join(ctes)])
+    base_sql, base_params = as_sql()
+
+    if explain_query_or_info:
+        setattr(query, explain_attribute, explain_query_or_info)
+
+    sql.append(base_sql)
+    params.extend(base_params)
+    return " ".join(sql), tuple(params)
+
+
+def get_cte_query_template(cte):
+    if cte.materialized:
+        return "{name} AS MATERIALIZED ({query})"
+    return "{name} AS ({query})"
+
+
+def _ignore_with_col_aliases(cte_query):
+    if getattr(cte_query, "combined_queries", None):
+        cte_query.combined_queries = tuple(
+            jit_mixin(q, NoAliasQuery) for q in cte_query.combined_queries
+        )
+
+
+class CTECompiler(JITMixin):
+    """Mixin for django.db.models.sql.compiler.SQLCompiler"""
+    _jit_mixin_prefix = "CTE"
+
+    def as_sql(self, *args, **kwargs):
+        def _as_sql():
+            return super(CTECompiler, self).as_sql(*args, **kwargs)
+        return generate_cte_sql(self.connection, self.query, _as_sql)
+
+
+class NoAliasQuery(JITMixin):
+    """Mixin for django.db.models.sql.compiler.Query"""
+    _jit_mixin_prefix = "NoAlias"
+
+    def get_compiler(self, *args, **kwargs):
+        return jit_mixin(super().get_compiler(*args, **kwargs), NoAliasCompiler)
+
+
+class NoAliasCompiler(JITMixin):
+    """Mixin for django.db.models.sql.compiler.SQLCompiler"""
+    _jit_mixin_prefix = "NoAlias"
+
+    def get_select(self, *, with_col_aliases=False, **kw):
+        return super().get_select(**kw)

{django_cte-1.3.3.dev20250530125340 → django_cte-2.0.0.dev20250610173146}/django_cte/raw.py

@@ -7,14 +7,14 @@ def raw_cte_sql(sql, params, refs):
     :returns: Object that can be passed to `With`.
     """
 
-    class raw_cte_ref(object):
+    class raw_cte_ref:
         def __init__(self, output_field):
             self.output_field = output_field
 
         def get_source_expressions(self):
             return []
 
-    class raw_cte_compiler(object):
+    class raw_cte_compiler:
 
         def __init__(self, connection):
             self.connection = connection
@@ -25,8 +25,8 @@ def raw_cte_sql(sql, params, refs):
         def quote_name_unless_alias(self, name):
             return self.connection.ops.quote_name(name)
 
-    class raw_cte_queryset(object):
-        class query(object):
+    class raw_cte_queryset:
+        class query:
             @staticmethod
             def get_compiler(connection, *, elide_empty=None):
                 return raw_cte_compiler(connection)

django_cte-1.3.3.dev20250530125340/django_cte/__init__.py

@@ -1,3 +0,0 @@
-from .cte import CTEManager, CTEQuerySet, With  # noqa
-
-__version__ = "1.3.3.dev20250530125340"

django_cte-1.3.3.dev20250530125340/django_cte/expressions.py

@@ -1,45 +0,0 @@
-from django.db.models import Subquery
-
-
-class CTESubqueryResolver(object):
-
-    def __init__(self, annotation):
-        self.annotation = annotation
-
-    def resolve_expression(self, *args, **kw):
-        # source: django.db.models.expressions.Subquery.resolve_expression
-        # --- begin copied code (lightly adapted) --- #
-
-        # Need to recursively resolve these.
-        def resolve_all(child):
-            if hasattr(child, 'children'):
-                [resolve_all(_child) for _child in child.children]
-            if hasattr(child, 'rhs'):
-                child.rhs = resolve(child.rhs)
-
-        def resolve(child):
-            if hasattr(child, 'resolve_expression'):
-                resolved = child.resolve_expression(*args, **kw)
-                # Add table alias to the parent query's aliases to prevent
-                # quoting.
-                if hasattr(resolved, 'alias') and \
-                        resolved.alias != resolved.target.model._meta.db_table:
-                    get_query(clone).external_aliases.add(resolved.alias)
-                return resolved
-            return child
-
-        # --- end copied code --- #
-
-        def get_query(clone):
-            return clone.query
-
-        # NOTE this uses the old (pre-Django 3) way of resolving.
-        # Should a different technique should be used on Django 3+?
-        clone = self.annotation.resolve_expression(*args, **kw)
-        if isinstance(self.annotation, Subquery):
-            for cte in getattr(get_query(clone), '_with_ctes', []):
-                resolve_all(cte.query.where)
-                for key, value in cte.query.annotations.items():
-                    if isinstance(value, Subquery):
-                        cte.query.annotations[key] = resolve(value)
-        return clone

django_cte-1.3.3.dev20250530125340/django_cte/query.py

@@ -1,194 +0,0 @@
-import django
-from django.core.exceptions import EmptyResultSet
-from django.db import connections
-from django.db.models.sql import DeleteQuery, Query, UpdateQuery
-from django.db.models.sql.compiler import (
-    SQLCompiler,
-    SQLDeleteCompiler,
-    SQLUpdateCompiler,
-)
-from django.db.models.sql.constants import LOUTER
-
-from .expressions import CTESubqueryResolver
-from .join import QJoin
-
-
-class CTEQuery(Query):
-    """A Query which processes SQL compilation through the CTE compiler"""
-
-    def __init__(self, *args, **kwargs):
-        super(CTEQuery, self).__init__(*args, **kwargs)
-        self._with_ctes = []
-
-    def combine(self, other, connector):
-        if other._with_ctes:
-            if self._with_ctes:
-                raise TypeError("cannot merge queries with CTEs on both sides")
-            self._with_ctes = other._with_ctes[:]
-        return super(CTEQuery, self).combine(other, connector)
-
-    def get_compiler(self, using=None, connection=None, *args, **kwargs):
-        """ Overrides the Query method get_compiler in order to return
-            a CTECompiler.
-        """
-        # Copy the body of this method from Django except the final
-        # return statement. We will ignore code coverage for this.
-        if using is None and connection is None:  # pragma: no cover
-            raise ValueError("Need either using or connection")
-        if using:
-            connection = connections[using]
-        # Check that the compiler will be able to execute the query
-        for alias, aggregate in self.annotation_select.items():
-            connection.ops.check_expression_support(aggregate)
-        # Instantiate the custom compiler.
-        klass = COMPILER_TYPES.get(self.__class__, CTEQueryCompiler)
-        return klass(self, connection, using, *args, **kwargs)
-
-    def add_annotation(self, annotation, *args, **kw):
-        annotation = CTESubqueryResolver(annotation)
-        super(CTEQuery, self).add_annotation(annotation, *args, **kw)
-
-    def __chain(self, _name, klass=None, *args, **kwargs):
-        klass = QUERY_TYPES.get(klass, self.__class__)
-        clone = getattr(super(CTEQuery, self), _name)(klass, *args, **kwargs)
-        clone._with_ctes = self._with_ctes[:]
-        return clone
-
-    def chain(self, klass=None):
-        return self.__chain("chain", klass)
-
-
-class CTECompiler(object):
-
-    @classmethod
-    def generate_sql(cls, connection, query, as_sql):
-        if not query._with_ctes:
-            return as_sql()
-
-        ctes = []
-        params = []
-        for cte in query._with_ctes:
-            if django.VERSION > (4, 2):
-                _ignore_with_col_aliases(cte.query)
-
-            alias = query.alias_map.get(cte.name)
-            should_elide_empty = (
-                    not isinstance(alias, QJoin) or alias.join_type != LOUTER
-            )
-
-            compiler = cte.query.get_compiler(
-                connection=connection, elide_empty=should_elide_empty
-            )
-
-            qn = compiler.quote_name_unless_alias
-            try:
-                cte_sql, cte_params = compiler.as_sql()
-            except EmptyResultSet:
-                # If the CTE raises an EmptyResultSet the SqlCompiler still
-                # needs to know the information about this base compiler
-                # like, col_count and klass_info.
-                as_sql()
-                raise
-            template = cls.get_cte_query_template(cte)
-            ctes.append(template.format(name=qn(cte.name), query=cte_sql))
-            params.extend(cte_params)
-
-        explain_attribute = "explain_info"
-        explain_info = getattr(query, explain_attribute, None)
-        explain_format = getattr(explain_info, "format", None)
-        explain_options = getattr(explain_info, "options", {})
-
-        explain_query_or_info = getattr(query, explain_attribute, None)
-        sql = []
-        if explain_query_or_info:
-            sql.append(
-                connection.ops.explain_query_prefix(
-                    explain_format,
-                    **explain_options
-                )
-            )
-            # this needs to get set to None so that the base as_sql() doesn't
-            # insert the EXPLAIN statement where it would end up between the
-            # WITH ... clause and the final SELECT
-            setattr(query, explain_attribute, None)
-
-        if ctes:
-            # Always use WITH RECURSIVE
-            # https://www.postgresql.org/message-id/13122.1339829536%40sss.pgh.pa.us
-            sql.extend(["WITH RECURSIVE", ", ".join(ctes)])
-        base_sql, base_params = as_sql()
-
-        if explain_query_or_info:
-            setattr(query, explain_attribute, explain_query_or_info)
-
-        sql.append(base_sql)
-        params.extend(base_params)
-        return " ".join(sql), tuple(params)
-
-    @classmethod
-    def get_cte_query_template(cls, cte):
-        if cte.materialized:
-            return "{name} AS MATERIALIZED ({query})"
-        return "{name} AS ({query})"
-
-
-class CTEUpdateQuery(UpdateQuery, CTEQuery):
-    pass
-
-
-class CTEDeleteQuery(DeleteQuery, CTEQuery):
-    pass
-
-
-QUERY_TYPES = {
-    Query: CTEQuery,
-    UpdateQuery: CTEUpdateQuery,
-    DeleteQuery: CTEDeleteQuery,
-}
-
-
-def _ignore_with_col_aliases(cte_query):
-    if getattr(cte_query, "combined_queries", None):
-        for query in cte_query.combined_queries:
-            query.ignore_with_col_aliases = True
-
-
-class CTEQueryCompiler(SQLCompiler):
-
-    def as_sql(self, *args, **kwargs):
-        def _as_sql():
-            return super(CTEQueryCompiler, self).as_sql(*args, **kwargs)
-        return CTECompiler.generate_sql(self.connection, self.query, _as_sql)
-
-    def get_select(self, **kw):
-        if kw.get("with_col_aliases") \
-                and getattr(self.query, "ignore_with_col_aliases", False):
-            kw.pop("with_col_aliases")
-        return super().get_select(**kw)
-
-
-class CTEUpdateQueryCompiler(SQLUpdateCompiler):
-
-    def as_sql(self, *args, **kwargs):
-        def _as_sql():
-            return super(CTEUpdateQueryCompiler, self).as_sql(*args, **kwargs)
-        return CTECompiler.generate_sql(self.connection, self.query, _as_sql)
-
-
-class CTEDeleteQueryCompiler(SQLDeleteCompiler):
-
-    # NOTE: it is currently not possible to execute delete queries that
-    # reference CTEs without patching `QuerySet.delete` (Django method)
-    # to call `self.query.chain(sql.DeleteQuery)` instead of
-    # `sql.DeleteQuery(self.model)`
-
-    def as_sql(self, *args, **kwargs):
-        def _as_sql():
-            return super(CTEDeleteQueryCompiler, self).as_sql(*args, **kwargs)
-        return CTECompiler.generate_sql(self.connection, self.query, _as_sql)
-
-
-COMPILER_TYPES = {
-    CTEUpdateQuery: CTEUpdateQueryCompiler,
-    CTEDeleteQuery: CTEDeleteQueryCompiler,
-}