django-cte 2.0.1.dev20251120124810__py3-none-any.whl

django_cte/__init__.py

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

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/cte.py

@@ -0,0 +1,231 @@
+from copy import copy
+
+import django
+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
+
+    :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 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").
+    This must be a unique name that does not conflict with other
+    entities (tables, views, functions, other CTE(s), etc.) referenced
+    in the given query as well any query to which this CTE will
+    eventually be added.
+    :param materialized: Optional parameter (default: False) which enforce
+    using of MATERIALIZED statement for supporting databases.
+    """
+
+    def __init__(self, queryset, name="cte", materialized=False):
+        self._set_queryset(queryset)
+        self.name = name
+        self.col = CTEColumns(self)
+        self.materialized = materialized
+
+    def __getstate__(self):
+        return (self.query, self.name, self.materialized, self._iterable_class)
+
+    def __setstate__(self, state):
+        if len(state) == 3:
+            # Keep compatibility with the previous serialization method
+            self.query, self.name, self.materialized = state
+            self._iterable_class = ValuesIterable
+        else:
+            self.query, self.name, self.materialized, self._iterable_class = state
+        self.col = CTEColumns(self)
+
+    def __repr__(self):
+        return f"<{type(self).__name__} {self.name}>"
+
+    def _set_queryset(self, queryset):
+        self.query = None if queryset is None else queryset.query
+        self._iterable_class = getattr(queryset, "_iterable_class", ValuesIterable)
+
+    @classmethod
+    def recursive(cls, make_cte_queryset, name="cte", materialized=False):
+        """Recursive Common Table Expression
+
+        :param make_cte_queryset: Function taking a single argument (a
+        not-yet-fully-constructed cte object) and returning a `QuerySet`
+        object. The returned `QuerySet` normally consists of an initial
+        statement unioned with a recursive statement.
+        :param name: See `name` parameter of `__init__`.
+        :param materialized: See `materialized` parameter of `__init__`.
+        :returns: The fully constructed recursive cte object.
+        """
+        cte = cls(None, name, materialized)
+        cte._set_queryset(make_cte_queryset(cte))
+        return cte
+
+    def join(self, model_or_queryset, *filter_q, **filter_kw):
+        """Join this CTE to the given model or queryset
+
+        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 `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.
+        :param *filter_q: Join condition Q expressions (optional).
+        :param **filter_kw: Join conditions. All LHS fields (kwarg keys)
+        are assumed to reference `model_or_queryset` fields. Use
+        `cte.col.name` on the RHS to recursively reference CTE query
+        columns. For example: `cte.join(Book, id=cte.col.id)`
+        :returns: A queryset with the given model or queryset joined to
+        this CTE.
+        """
+        if isinstance(model_or_queryset, QuerySet):
+            queryset = model_or_queryset.all()
+        else:
+            queryset = model_or_queryset._default_manager.all()
+        join_type = filter_kw.pop("_join_type", INNER)
+        query = queryset.query
+
+        # based on Query.add_q: add necessary joins to query, but no filter
+        q_object = Q(*filter_q, **filter_kw)
+        map = query.alias_map
+        existing_inner = set(a for a in map if map[a].join_type == INNER)
+        if django.VERSION >= (5, 2):
+            on_clause, _ = query._add_q(
+                q_object, query.used_aliases, update_join_types=(join_type == INNER)
+            )
+        else:
+            on_clause, _ = query._add_q(q_object, query.used_aliases)
+        query.demote_joins(existing_inner)
+
+        parent = query.get_initial_alias()
+        query.join(QJoin(parent, self.name, self.name, on_clause, join_type))
+        return queryset
+
+    def queryset(self):
+        """Get a queryset selecting from this CTE
+
+        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 `with_cte(cte, select=cte)` to do
+        that.
+
+        :returns: A queryset.
+        """
+        cte_query = self.query
+        qs = cte_query.model._default_manager.get_queryset()
+        qs._iterable_class = self._iterable_class
+        qs._fields = ()  # Allow any field names to be used in further annotations
+
+        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
+
+        if django.VERSION < (5, 2) and cte_query.values_select:
+            query.set_values(cte_query.values_select)
+
+        if cte_query.annotations:
+            for alias, value in cte_query.annotations.items():
+                col = CTEColumnRef(alias, self.name, value.output_field)
+                query.add_annotation(col, alias)
+        query.annotation_select_mask = cte_query.annotation_select_mask
+
+        if selected := getattr(cte_query, "selected", None):
+            for alias in selected:
+                if alias not in cte_query.annotations:
+                    output_field = cte_query.resolve_ref(alias).output_field
+                    col = CTEColumnRef(alias, self.name, output_field)
+                    query.add_annotation(col, alias)
+            query.selected = {alias: alias for alias in selected}
+
+        qs.query = query
+        return qs
+
+    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.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.
+        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):
+        qs = self._clone()
+        qs.query._with_ctes += cte,
+        return qs
+
+    def as_manager(cls):
+        # Address the circular dependency between
+        # `CTEQuerySet` and `CTEManager`.
+        manager = CTEManager.from_queryset(cls)()
+        manager._built_with_as_manager = True
+        return manager
+    as_manager.queryset_only = True
+    as_manager = classmethod(as_manager)
+
+
+@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"""
+
+    @classmethod
+    def from_queryset(cls, queryset_class, class_name=None):
+        if not issubclass(queryset_class, CTEQuerySet):
+            raise TypeError(
+                "models with CTE support need to use a CTEQuerySet")
+        return super(CTEManager, cls).from_queryset(
+            queryset_class, class_name=class_name)

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/join.py

@@ -0,0 +1,91 @@
+from django.db.models.sql.constants import INNER
+
+
+class QJoin:
+    """Join clause with join condition from Q object clause
+
+    :param parent_alias: Alias of parent table.
+    :param table_name: Name of joined table.
+    :param table_alias: Alias of joined table.
+    :param on_clause: Query `where_class` instance represenging the ON clause.
+    :param join_type: Join type (INNER or LOUTER).
+    """
+
+    filtered_relation = None
+
+    def __init__(self, parent_alias, table_name, table_alias,
+                 on_clause, join_type=INNER, nullable=None):
+        self.parent_alias = parent_alias
+        self.table_name = table_name
+        self.table_alias = table_alias
+        self.on_clause = on_clause
+        self.join_type = join_type  # LOUTER or INNER
+        self.nullable = join_type != INNER if nullable is None else nullable
+
+    @property
+    def identity(self):
+        return (
+            self.__class__,
+            self.table_name,
+            self.parent_alias,
+            self.join_type,
+            self.on_clause,
+        )
+
+    def __hash__(self):
+        return hash(self.identity)
+
+    def __eq__(self, other):
+        if not isinstance(other, QJoin):
+            return NotImplemented
+        return self.identity == other.identity
+
+    def equals(self, other):
+        return self.identity == other.identity
+
+    def as_sql(self, compiler, connection):
+        """Generate join clause SQL"""
+        on_clause_sql, params = self.on_clause.as_sql(compiler, connection)
+        if self.table_alias == self.table_name:
+            alias = ''
+        else:
+            alias = ' %s' % self.table_alias
+        qn = compiler.quote_name_unless_alias
+        sql = '%s %s%s ON %s' % (
+            self.join_type,
+            qn(self.table_name),
+            alias,
+            on_clause_sql
+        )
+        return sql, params
+
+    def relabeled_clone(self, change_map):
+        return self.__class__(
+            parent_alias=change_map.get(self.parent_alias, self.parent_alias),
+            table_name=self.table_name,
+            table_alias=change_map.get(self.table_alias, self.table_alias),
+            on_clause=self.on_clause.relabeled_clone(change_map),
+            join_type=self.join_type,
+            nullable=self.nullable,
+        )
+
+    class join_field:
+        # `Join.join_field` is used internally by `Join` as well as in
+        # `QuerySet.resolve_expression()`:
+        #
+        #    isinstance(table, Join)
+        #    and table.join_field.related_model._meta.db_table != alias
+        #
+        # Currently that does not apply here since `QJoin` is not an
+        # instance of `Join`, although maybe it should? Maybe this
+        # should have `related_model._meta.db_table` return
+        # `<QJoin>.table_name` or `<QJoin>.table_alias`?
+        #
+        # `PathInfo.join_field` is another similarly named attribute in
+        # Django that has a much more complicated interface, but luckily
+        # seems unrelated to `Join.join_field`.
+
+        class related_model:
+            class _meta:
+                # for QuerySet.set_group_by(allow_aliases=True)
+                local_concrete_fields = ()

django_cte/meta.py

@@ -0,0 +1,112 @@
+import weakref
+
+from django.db.models.expressions import Col, Expression
+
+
+class CTEColumns:
+
+    def __init__(self, cte):
+        self._cte = weakref.ref(cte)
+
+    def __getattr__(self, name):
+        return CTEColumn(self._cte(), name)
+
+
+class CTEColumn(Expression):
+
+    def __init__(self, cte, name, output_field=None):
+        self._cte = cte
+        self.table_alias = cte.name
+        self.name = self.alias = name
+        self._output_field = output_field
+
+    def __repr__(self):
+        return "<{} {}.{}>".format(
+            self.__class__.__name__,
+            self._cte.name,
+            self.name,
+        )
+
+    @property
+    def _ref(self):
+        if self._cte.query is None:
+            raise ValueError(
+                "cannot resolve '{cte}.{name}' in recursive CTE setup. "
+                "Hint: use ExpressionWrapper({cte}.col.{name}, "
+                "output_field=...)".format(cte=self._cte.name, name=self.name)
+            )
+        ref = self._cte._resolve_ref(self.name)
+        if ref is self or self in ref.get_source_expressions():
+            raise ValueError("Circular reference: {} = {}".format(self, ref))
+        return ref
+
+    @property
+    def target(self):
+        return self._ref.target
+
+    @property
+    def output_field(self):
+        # required to fix error caused by django commit
+        #     9d519d3dc4e5bd1d9ff3806b44624c3e487d61c1
+        if self._cte.query is None:
+            raise AttributeError
+
+        if self._output_field is not None:
+            return self._output_field
+        return self._ref.output_field
+
+    def as_sql(self, compiler, connection):
+        qn = compiler.quote_name_unless_alias
+        ref = self._ref
+        if isinstance(ref, Col) and self.name == "pk":
+            column = ref.target.column
+        else:
+            column = self.name
+        return "%s.%s" % (qn(self.table_alias), qn(column)), []
+
+    def relabeled_clone(self, relabels):
+        if self.table_alias is not None and self.table_alias in relabels:
+            clone = self.copy()
+            clone.table_alias = relabels[self.table_alias]
+            return clone
+        return self
+
+
+class CTEColumnRef(Expression):
+
+    def __init__(self, name, cte_name, output_field):
+        self.name = name
+        self.cte_name = cte_name
+        self.output_field = output_field
+        self._alias = None
+
+    def resolve_expression(self, query=None, allow_joins=True, reuse=None,
+                           summarize=False, for_save=False):
+        if query:
+            clone = self.copy()
+            clone._alias = self._alias or query.table_map.get(
+                self.cte_name, [self.cte_name])[0]
+            return clone
+        return super().resolve_expression(
+            query, allow_joins, reuse, summarize, for_save)
+
+    def relabeled_clone(self, change_map):
+        if (
+            self.cte_name not in change_map
+            and self._alias not in change_map
+        ):
+            return super().relabeled_clone(change_map)
+
+        clone = self.copy()
+        if self.cte_name in change_map:
+            clone._alias = change_map[self.cte_name]
+
+        if self._alias in change_map:
+            clone._alias = change_map[self._alias]
+        return clone
+
+    def as_sql(self, compiler, connection):
+        qn = compiler.quote_name_unless_alias
+        table = self._alias or compiler.query.table_map.get(
+            self.cte_name, [self.cte_name])[0]
+        return "%s.%s" % (qn(table), qn(self.name)), []

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/raw.py

@@ -0,0 +1,38 @@
+def raw_cte_sql(sql, params, refs):
+    """Raw CTE SQL
+
+    :param sql: SQL query (string).
+    :param params: List of bind parameters.
+    :param refs: Dict of output fields: `{"name": <Field instance>}`.
+    :returns: Object that can be passed to `With`.
+    """
+
+    class raw_cte_ref:
+        def __init__(self, output_field):
+            self.output_field = output_field
+
+        def get_source_expressions(self):
+            return []
+
+    class raw_cte_compiler:
+
+        def __init__(self, connection):
+            self.connection = connection
+
+        def as_sql(self):
+            return sql, params
+
+        def quote_name_unless_alias(self, name):
+            return self.connection.ops.quote_name(name)
+
+    class raw_cte_queryset:
+        class query:
+            @staticmethod
+            def get_compiler(connection, *, elide_empty=None):
+                return raw_cte_compiler(connection)
+
+            @staticmethod
+            def resolve_ref(name):
+                return raw_cte_ref(refs[name])
+
+    return raw_cte_queryset

django_cte-2.0.1.dev20251120124810.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: django-cte
+Version: 2.0.1.dev20251120124810
+Summary: Common Table Expressions (CTE) for Django
+Author-email: Daniel Miller <millerdev@gmail.com>
+Requires-Python: >= 3.9
+Description-Content-Type: text/markdown
+License-Expression: BSD-3-Clause
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+License-File: LICENSE
+Requires-Dist: django
+Project-URL: Home, https://github.com/dimagi/django-cte
+
+# Common Table Expressions with Django
+
+[![Build Status](https://github.com/dimagi/django-cte/actions/workflows/tests.yml/badge.svg)](https://github.com/dimagi/django-cte/actions/workflows/tests.yml)
+[![PyPI version](https://badge.fury.io/py/django-cte.svg)](https://badge.fury.io/py/django-cte)
+
+## Installation
+```
+pip install django-cte
+```
+
+
+## Documentation
+
+The [django-cte documentation](https://dimagi.github.io/django-cte/) shows how
+to use Common Table Expressions with the Django ORM.
+
+
+## Running tests
+
+```
+cd django-cte
+uv sync
+
+pytest
+ruff check
+
+# To run tests against postgres
+psql -U username -h localhost -p 5432 -c 'create database django_cte;'
+export PG_DB_SETTINGS='{
+    "ENGINE":"django.db.backends.postgresql_psycopg2",
+    "NAME":"django_cte",
+    "USER":"username",
+    "PASSWORD":"password",
+    "HOST":"localhost",
+    "PORT":"5432"}'
+
+# WARNING pytest will delete the test_django_cte database if it exists!
+DB_SETTINGS="$PG_DB_SETTINGS" pytest
+```
+
+All feature and bug contributions are expected to be covered by tests.
+
+
+## Publishing a new verison to PyPI
+
+Push a new tag to Github using the format vX.Y.Z where X.Y.Z matches the version
+in [`__init__.py`](django_cte/__init__.py).
+
+A new version is published to https://test.pypi.org/p/django-cte on every
+push to the *main* branch.
+
+Publishing is automated with [Github Actions](.github/workflows/pypi.yml).
+

django_cte-2.0.1.dev20251120124810.dist-info/RECORD

@@ -0,0 +1,12 @@
+django_cte/__init__.py,sha256=yZ7JoQz-Vxue4HW_uP6-knUYwqPe75Qx__CEvIvUJNM,141
+django_cte/_deprecated.py,sha256=OAEmWVqnoi-27m2nyrfTIwVwPE1J8VLrfspgRHW-EZI,5623
+django_cte/cte.py,sha256=E3wLUzxDecoNS2vza764hsQvnloFWK2Fan1lK6xfK8Q,9087
+django_cte/jitmixin.py,sha256=JRTRlbBhD8XD0GHwxg8wKdJSbcTv_zUrSyqtOSfgM5M,885
+django_cte/join.py,sha256=2b1iBKFFiqBqYBmX4W9q2RfX17xXjZbbzClpUdbnUtA,3156
+django_cte/meta.py,sha256=gNBtegkvg5CXcEPyt1nZMIF2UlsPMTUPStVJSsRni3I,3491
+django_cte/query.py,sha256=djY7Bknl_NQSd1g6zy8N3fU3h2r8OfpyeJY_Zt9a7fg,5582
+django_cte/raw.py,sha256=6_YDCKBsgXx1oQku4EcyK4qJmnmiyzEeZRxiYdkg8Y8,1045
+django_cte-2.0.1.dev20251120124810.dist-info/licenses/LICENSE,sha256=mkLNw_QhpZ40jBEbuAosqH4ciA3KMrwb8aSYbTmy5gc,1508
+django_cte-2.0.1.dev20251120124810.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+django_cte-2.0.1.dev20251120124810.dist-info/METADATA,sha256=dW2kH1gGOkV9kM7T7TgtR06QR1o_RKvM9tJxtF_kWzM,2646
+django_cte-2.0.1.dev20251120124810.dist-info/RECORD,,

django_cte-2.0.1.dev20251120124810.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any

django_cte-2.0.1.dev20251120124810.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2018, Dimagi Inc., and individual contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name Dimagi, nor the names of its contributors, may be used
+      to endorse or promote products derived from this software without
+      specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL DIMAGI INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.