django-cte 1.3.3.dev20250526204410__py3-none-any.whl

django_cte/__init__.py

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

django_cte/cte.py

@@ -0,0 +1,166 @@
+from django.db.models import Manager
+from django.db.models.query import Q, QuerySet, ValuesIterable
+from django.db.models.sql.datastructures import BaseTable
+
+from .join import QJoin, INNER
+from .meta import CTEColumnRef, CTEColumns
+from .query import CTEQuery
+
+__all__ = ["With", "CTEManager", "CTEQuerySet"]
+
+
+class With(object):
+    """Common Table Expression query object: `WITH ...`
+
+    :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.query = None if queryset is None else queryset.query
+        self.name = name
+        self.col = CTEColumns(self)
+        self.materialized = materialized
+
+    def __getstate__(self):
+        return (self.query, self.name, self.materialized)
+
+    def __setstate__(self, state):
+        self.query, self.name, self.materialized = state
+        self.col = CTEColumns(self)
+
+    def __repr__(self):
+        return "<With {}>".format(self.name)
+
+    @classmethod
+    def recursive(cls, make_cte_queryset, name="cte", materialized=False):
+        """Recursive Common Table Expression: `WITH RECURSIVE ...`
+
+        :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.query = make_cte_queryset(cte).query
+        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 refernced 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.
+
+        :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)
+        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 `<CTEQuerySet>.with_cte(cte)` to
+        achieve that outcome.
+
+        :returns: A queryset.
+        """
+        cte_query = self.query
+        qs = cte_query.model._default_manager.get_queryset()
+
+        query = CTEQuery(cte_query.model)
+        query.join(BaseTable(self.name, None))
+        query.default_cols = cte_query.default_cols
+        query.deferred_loading = cte_query.deferred_loading
+        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)
+        if cte_query.values_select:
+            query.set_values(cte_query.values_select)
+            qs._iterable_class = ValuesIterable
+        query.annotation_select_mask = cte_query.annotation_select_mask
+
+        qs.query = query
+        return qs
+
+    def _resolve_ref(self, name):
+        return self.query.resolve_ref(name)
+
+
+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)
+
+    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)
+        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)
+
+
+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/expressions.py

@@ -0,0 +1,50 @@
+import django
+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 --- #
+
+        if django.VERSION < (3, 0):
+            def get_query(clone):
+                return clone.queryset.query
+        else:
+            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/join.py

@@ -0,0 +1,91 @@
+from django.db.models.sql.constants import INNER
+
+
+class QJoin(object):
+    """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(object):
+
+    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(CTEColumnRef, self).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(CTEColumnRef, self).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,222 @@
+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 django.db.models.sql.where import ExtraWhere, WhereNode
+
+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
+
+    if django.VERSION < (2, 0):
+        def clone(self, klass=None, *args, **kwargs):
+            return self.__chain("clone", klass, *args, **kwargs)
+
+    else:
+        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
+            )
+
+            if django.VERSION >= (4, 0):
+                compiler = cte.query.get_compiler(
+                    connection=connection, elide_empty=should_elide_empty
+                )
+            else:
+                compiler = cte.query.get_compiler(connection=connection)
+
+            qn = compiler.quote_name_unless_alias
+            try:
+                cte_sql, cte_params = compiler.as_sql()
+            except EmptyResultSet:
+                if django.VERSION < (4, 0) and not should_elide_empty:
+                    # elide_empty is not available prior to Django 4.0. The
+                    # below behavior emulates the logic of it, rebuilding
+                    # the CTE query with a WHERE clause that is always false
+                    # but that the SqlCompiler cannot optimize away. This is
+                    # only required for left outer joins, as standard inner
+                    # joins should be optimized and raise the EmptyResultSet
+                    query = cte.query.copy()
+                    query.where = WhereNode([ExtraWhere(["1 = 0"], [])])
+                    compiler = query.get_compiler(connection=connection)
+                    cte_sql, cte_params = compiler.as_sql()
+                else:
+                    # 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)
+
+        # Required due to breaking change in django commit
+        #     fc91ea1e50e5ef207f0f291b3f6c1942b10db7c7
+        if django.VERSION >= (4, 0):
+            explain_attribute = "explain_info"
+            explain_info = getattr(query, explain_attribute, None)
+            explain_format = getattr(explain_info, "format", None)
+            explain_options = getattr(explain_info, "options", {})
+        else:
+            explain_attribute = "explain_query"
+            explain_format = getattr(query, "explain_format", None)
+            explain_options = getattr(query, "explain_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,
+}

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(object):
+        def __init__(self, output_field):
+            self.output_field = output_field
+
+        def get_source_expressions(self):
+            return []
+
+    class raw_cte_compiler(object):
+
+        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(object):
+        class query(object):
+            @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-1.3.3.dev20250526204410.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: django-cte
+Version: 1.3.3.dev20250526204410
+Summary: Common Table Expressions (CTE) for Django
+Author-email: Daniel Miller <millerdev@gmail.com>
+Requires-Python: >= 3.9
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+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: Framework :: Django
+Classifier: Framework :: Django :: 4
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+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-1.3.3.dev20250526204410.dist-info/RECORD

@@ -0,0 +1,11 @@
+django_cte/__init__.py,sha256=VFBvWKXfBtqdPTJcYi67U8mUDTxntsQxpHrjrGdCRhE,96
+django_cte/cte.py,sha256=Xw2Ll-O3fujrQF-dsvXdQy4FzG8fQdsLYJk6GCXRI3M,6554
+django_cte/expressions.py,sha256=taT2trCz4z0YmOGVXzR9XXquPR43OH6xghNWAplc3lM,1930
+django_cte/join.py,sha256=HrO31WKx3j5RiEWf7dDOXbBfeeUPFEbNLo3gzzt3qbo,3164
+django_cte/meta.py,sha256=PIu7iW_tu3gBCpiBRfVHvuJKSSND2IsaNhoT01WEEJM,3535
+django_cte/query.py,sha256=A16buWFqWJZ2RA1WUby7tdC_uxmn9XNLuCewjJAg1mk,8314
+django_cte/raw.py,sha256=nROVPEVRc3_zKAFcED6KR8Rr6FTTn8jQDFQWfi-X3-A,1077
+django_cte-1.3.3.dev20250526204410.dist-info/licenses/LICENSE,sha256=mkLNw_QhpZ40jBEbuAosqH4ciA3KMrwb8aSYbTmy5gc,1508
+django_cte-1.3.3.dev20250526204410.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+django_cte-1.3.3.dev20250526204410.dist-info/METADATA,sha256=BoO5aEF98J-66izORnA7QYxj_OB7cF80136D0NyoikM,2645
+django_cte-1.3.3.dev20250526204410.dist-info/RECORD,,

django_cte-1.3.3.dev20250526204410.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-1.3.3.dev20250526204410.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.