Merge remote-tracking branch 'upstream/main'

Author: dan-mm

django/contrib/gis/db/backends/base/features.py

@@ -2,6 +2,8 @@
 
 from django.contrib.gis.db import models
 
+from .operations import BaseSpatialOperations
+
 
 class BaseSpatialFeatures:
     gis_enabled = True
@@ -107,5 +109,11 @@ def __getattr__(self, name):
         m = re.match(r"has_(\w*)_function$", name)
         if m:
             func_name = m[1]
+            if func_name not in BaseSpatialOperations.unsupported_functions:
+                raise ValueError(
+                    f"DatabaseFeatures.has_{func_name}_function isn't valid. "
+                    f'Is "{func_name}" missing from '
+                    "BaseSpatialOperations.unsupported_functions?"
+                )
             return func_name not in self.connection.ops.unsupported_functions
         raise AttributeError

django/contrib/gis/db/backends/base/operations.py

@@ -39,13 +39,17 @@ def select_extent(self):
         "AsGML",
         "AsKML",
         "AsSVG",
+        "AsWKB",
+        "AsWKT",
         "Azimuth",
         "BoundingCircle",
         "Centroid",
         "ClosestPoint",
         "Difference",
         "Distance",
+        "DistanceSpheroid",
         "Envelope",
+        "ForcePolygonCW",
         "FromWKB",
         "FromWKT",
         "GeoHash",

django/db/models/expressions.py

@@ -1711,14 +1711,24 @@ def as_sql(
             except EmptyResultSet:
                 continue
             except FullResultSet:
-                default_sql, default_params = compiler.compile(case.result)
+                default = case.result
                 break
             case_parts.append(case_sql)
             sql_params.extend(case_params)
         else:
-            default_sql, default_params = compiler.compile(self.default)
-        if not case_parts:
-            return default_sql, default_params
+            default = self.default
+        if case_parts:
+            default_sql, default_params = compiler.compile(default)
+        else:
+            if (
+                isinstance(default, Value)
+                and (output_field := default._output_field_or_none) is not None
+            ):
+                from django.db.models.functions import Cast
+
+                default = Cast(default, output_field)
+            return compiler.compile(default)
+
         case_joiner = case_joiner or self.case_joiner
         template_params["cases"] = case_joiner.join(case_parts)
         template_params["default"] = default_sql

django/test/utils.py

@@ -728,12 +728,13 @@ def __enter__(self):
         self.connection.ensure_connection()
         self.initial_queries = len(self.connection.queries_log)
         self.final_queries = None
-        request_started.disconnect(reset_queries)
+        self.reset_queries_disconnected = request_started.disconnect(reset_queries)
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):
         self.connection.force_debug_cursor = self.force_debug_cursor
-        request_started.connect(reset_queries)
+        if self.reset_queries_disconnected:
+            request_started.connect(reset_queries)
         if exc_type is not None:
             return
         self.final_queries = len(self.connection.queries_log)

tests/gis_tests/geoapp/test_functions.py

@@ -559,7 +559,7 @@ def test_memsize(self):
         # Exact value depends on database and version.
         self.assertTrue(20 <= ptown.size <= 105)
 
-    @skipUnlessDBFeature("has_NumGeom_function")
+    @skipUnlessDBFeature("has_NumGeometries_function")
     def test_num_geom(self):
         # Both 'countries' only have two geometries.
         for c in Country.objects.annotate(num_geom=functions.NumGeometries("mpoly")):
@@ -576,7 +576,7 @@ def test_num_geom(self):
             else:
                 self.assertEqual(1, city.num_geom)
 
-    @skipUnlessDBFeature("has_NumPoint_function")
+    @skipUnlessDBFeature("has_NumPoints_function")
     def test_num_points(self):
         coords = [(-95.363151, 29.763374), (-95.448601, 29.713803)]
         Track.objects.create(name="Foo", line=LineString(coords))

tests/gis_tests/tests.py

@@ -1,8 +1,9 @@
 import unittest
 
 from django.core.exceptions import ImproperlyConfigured
-from django.db import ProgrammingError
+from django.db import ProgrammingError, connection
 from django.db.backends.base.base import NO_DB_ALIAS
+from django.test import TestCase
 
 try:
     from django.contrib.gis.db.backends.postgis.operations import PostGISOperations
@@ -12,6 +13,16 @@
     HAS_POSTGRES = False
 
 
+class BaseSpatialFeaturesTests(TestCase):
+    def test_invalid_has_func_function(self):
+        msg = (
+            'DatabaseFeatures.has_Invalid_function isn\'t valid. Is "Invalid" '
+            "missing from BaseSpatialOperations.unsupported_functions?"
+        )
+        with self.assertRaisesMessage(ValueError, msg):
+            connection.features.has_Invalid_function
+
+
 if HAS_POSTGRES:
 
     class FakeConnection:

tests/ordering/tests.py

@@ -3,15 +3,18 @@
 
 from django.core.exceptions import FieldError
 from django.db.models import (
+    Case,
     CharField,
     Count,
     DateTimeField,
     F,
+    IntegerField,
     Max,
     OrderBy,
     OuterRef,
     Subquery,
     Value,
+    When,
 )
 from django.db.models.functions import Length, Upper
 from django.test import TestCase
@@ -526,6 +529,17 @@ def test_order_by_constant_value(self):
         qs = Article.objects.order_by(Value("1", output_field=CharField()), "-headline")
         self.assertSequenceEqual(qs, [self.a4, self.a3, self.a2, self.a1])
 
+    def test_order_by_case_when_constant_value(self):
+        qs = Article.objects.order_by(
+            Case(
+                When(pk__in=[], then=Value(1)),
+                default=Value(0),
+                output_field=IntegerField(),
+            ).desc(),
+            "pk",
+        )
+        self.assertSequenceEqual(qs, [self.a1, self.a2, self.a3, self.a4])
+
     def test_related_ordering_duplicate_table_reference(self):
         """
         An ordering referencing a model with an ordering referencing a model

tests/test_utils/tests.py

@@ -386,6 +386,7 @@ class CaptureQueriesContextManagerTests(TestCase):
     @classmethod
     def setUpTestData(cls):
         cls.person_pk = str(Person.objects.create(name="test").pk)
+        cls.url = f"/test_utils/get_person/{cls.person_pk}/"
 
     def test_simple(self):
         with CaptureQueriesContext(connection) as captured_queries:
@@ -418,25 +419,38 @@ def test_failure(self):
 
     def test_with_client(self):
         with CaptureQueriesContext(connection) as captured_queries:
-            self.client.get("/test_utils/get_person/%s/" % self.person_pk)
+            self.client.get(self.url)
         self.assertEqual(len(captured_queries), 1)
         self.assertIn(self.person_pk, captured_queries[0]["sql"])
 
         with CaptureQueriesContext(connection) as captured_queries:
-            self.client.get("/test_utils/get_person/%s/" % self.person_pk)
+            self.client.get(self.url)
         self.assertEqual(len(captured_queries), 1)
         self.assertIn(self.person_pk, captured_queries[0]["sql"])
 
         with CaptureQueriesContext(connection) as captured_queries:
-            self.client.get("/test_utils/get_person/%s/" % self.person_pk)
-            self.client.get("/test_utils/get_person/%s/" % self.person_pk)
+            self.client.get(self.url)
+            self.client.get(self.url)
         self.assertEqual(len(captured_queries), 2)
         self.assertIn(self.person_pk, captured_queries[0]["sql"])
         self.assertIn(self.person_pk, captured_queries[1]["sql"])
 
+    def test_with_client_nested(self):
+        with CaptureQueriesContext(connection) as captured_queries:
+            Person.objects.count()
+            with CaptureQueriesContext(connection):
+                pass
+            self.client.get(self.url)
+        self.assertEqual(2, len(captured_queries))
+
 
 @override_settings(ROOT_URLCONF="test_utils.urls")
 class AssertNumQueriesContextManagerTests(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.person_pk = str(Person.objects.create(name="test").pk)
+        cls.url = f"/test_utils/get_person/{cls.person_pk}/"
+
     def test_simple(self):
         with self.assertNumQueries(0):
             pass
@@ -459,17 +473,22 @@ def test_failure(self):
                 raise TypeError
 
     def test_with_client(self):
-        person = Person.objects.create(name="test")
-
         with self.assertNumQueries(1):
-            self.client.get("/test_utils/get_person/%s/" % person.pk)
+            self.client.get(self.url)
 
         with self.assertNumQueries(1):
-            self.client.get("/test_utils/get_person/%s/" % person.pk)
+            self.client.get(self.url)
 
         with self.assertNumQueries(2):
-            self.client.get("/test_utils/get_person/%s/" % person.pk)
-            self.client.get("/test_utils/get_person/%s/" % person.pk)
+            self.client.get(self.url)
+            self.client.get(self.url)
+
+    def test_with_client_nested(self):
+        with self.assertNumQueries(2):
+            Person.objects.count()
+            with self.assertNumQueries(0):
+                pass
+            self.client.get(self.url)
 
 
 @override_settings(ROOT_URLCONF="test_utils.urls")