Merge pull request #92 from camuthig/fix-empty-result-set

Handle empty result sets in CTEs

Author: millerdev

django_cte/query.py

@@ -2,15 +2,19 @@
 from __future__ import unicode_literals
 
 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):
@@ -75,9 +79,40 @@ def generate_sql(cls, connection, query, as_sql):
         for cte in query._with_ctes:
             if django.VERSION > (4, 2):
                 _ignore_with_col_aliases(cte.query)
-            compiler = cte.query.get_compiler(connection=connection)
+
+            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
-            cte_sql, cte_params = compiler.as_sql()
+            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)

django_cte/raw.py

@@ -32,7 +32,7 @@ def quote_name_unless_alias(self, name):
     class raw_cte_queryset(object):
         class query(object):
             @staticmethod
-            def get_compiler(connection):
+            def get_compiler(connection, *, elide_empty=None):
                 return raw_cte_compiler(connection)
 
             @staticmethod

tests/test_cte.py

@@ -562,3 +562,41 @@ def test_explain(self):
         )
 
         self.assertIsInstance(orders.explain(), str)
+
+    def test_empty_result_set_cte(self):
+        """
+        Verifies that the CTEQueryCompiler can handle empty result sets in the
+        related CTEs
+        """
+        totals = With(
+            Order.objects
+            .filter(id__in=[])
+            .values("region_id")
+            .annotate(total=Sum("amount")),
+            name="totals",
+        )
+        orders = (
+            totals.join(Order, region=totals.col.region_id)
+            .with_cte(totals)
+            .annotate(region_total=totals.col.total)
+            .order_by("amount")
+        )
+
+        self.assertEqual(len(orders), 0)
+
+    def test_left_outer_join_on_empty_result_set_cte(self):
+        totals = With(
+            Order.objects
+            .filter(id__in=[])
+            .values("region_id")
+            .annotate(total=Sum("amount")),
+            name="totals",
+        )
+        orders = (
+            totals.join(Order, region=totals.col.region_id, _join_type=LOUTER)
+            .with_cte(totals)
+            .annotate(region_total=totals.col.total)
+            .order_by("amount")
+        )
+
+        self.assertEqual(len(orders), 22)