django-cte 1.3.3.dev20250526204410__tar.gz → 1.3.3.dev20250530125340__tar.gz

{django_cte-1.3.3.dev20250526204410 → django_cte-1.3.3.dev20250530125340}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-cte
-Version: 1.3.3.dev20250526204410
+Version: 1.3.3.dev20250530125340
 Summary: Common Table Expressions (CTE) for Django
 Author-email: Daniel Miller <millerdev@gmail.com>
 Requires-Python: >= 3.9
@@ -18,12 +18,13 @@ 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.0
 Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 License-File: LICENSE
 Requires-Dist: django

{django_cte-1.3.3.dev20250526204410 → django_cte-1.3.3.dev20250530125340}/django_cte/__init__.py

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

{django_cte-1.3.3.dev20250526204410 → django_cte-1.3.3.dev20250530125340}/django_cte/cte.py

@@ -1,4 +1,5 @@
 from django.db.models import Manager
+from django.db.models.expressions import Ref
 from django.db.models.query import Q, QuerySet, ValuesIterable
 from django.db.models.sql.datastructures import BaseTable
 
@@ -107,19 +108,27 @@ class With(object):
         query.join(BaseTable(self.name, None))
         query.default_cols = cte_query.default_cols
         query.deferred_loading = cte_query.deferred_loading
+        if cte_query.values_select:
+            query.set_values(cte_query.values_select)
+            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)
+                query.add_annotation(col, alias)
         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):
+        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 self.query.resolve_ref(name)
 
 
@@ -153,6 +162,35 @@ 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
+
 
 class CTEManager(Manager.from_queryset(CTEQuerySet)):
     """Manager for models that perform CTE queries"""

{django_cte-1.3.3.dev20250526204410 → django_cte-1.3.3.dev20250530125340}/django_cte/expressions.py

@@ -1,4 +1,3 @@
-import django
 from django.db.models import Subquery
 
 
@@ -31,12 +30,8 @@ class CTESubqueryResolver(object):
 
         # --- end copied code --- #
 
-        if django.VERSION < (3, 0):
-            def get_query(clone):
-                return clone.queryset.query
-        else:
-            def get_query(clone):
-                return clone.query
+        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+?

{django_cte-1.3.3.dev20250526204410 → django_cte-1.3.3.dev20250530125340}/django_cte/query.py

@@ -8,7 +8,6 @@ from django.db.models.sql.compiler import (
     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
@@ -55,13 +54,8 @@ class CTEQuery(Query):
         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)
+    def chain(self, klass=None):
+        return self.__chain("chain", klass)
 
 
 class CTECompiler(object):
@@ -82,49 +76,27 @@ class CTECompiler(object):
                     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)
+            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 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
+                # 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_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 = []

{django_cte-1.3.3.dev20250526204410 → django_cte-1.3.3.dev20250530125340}/pyproject.toml

@@ -6,6 +6,8 @@ license = {file = "LICENSE"}
 readme = {file = "README.md", content-type = "text/markdown"}
 dynamic = ["version"]
 requires-python = ">= 3.9"
+# Python and Django versions are read from this file by GitHub Actions.
+# Precise formatting is important.
 classifiers = [
     "Development Status :: 5 - Production/Stable",
     'Environment :: Web Environment',
@@ -20,12 +22,13 @@ classifiers = [
     'Programming Language :: Python :: 3.11',
     'Programming Language :: Python :: 3.12',
     'Programming Language :: Python :: 3.13',
+    'Programming Language :: Python :: 3.14',
     'Framework :: Django',
     'Framework :: Django :: 4',
     'Framework :: Django :: 4.2',
     'Framework :: Django :: 5',
-    'Framework :: Django :: 5.0',
     'Framework :: Django :: 5.1',
+    'Framework :: Django :: 5.2',
     'Topic :: Software Development :: Libraries :: Python Modules',
 ]
 dependencies = ["django"]