Merge remote-tracking branch 'upstream/main'

Author: dan-mm

django/contrib/gis/db/models/lookups.py

@@ -19,7 +19,7 @@ class GISLookup(Lookup):
     band_lhs = None
 
     def __init__(self, lhs, rhs):
-        rhs, *self.rhs_params = rhs if isinstance(rhs, (list, tuple)) else [rhs]
+        rhs, *self.rhs_params = rhs if isinstance(rhs, (list, tuple)) else (rhs,)
         super().__init__(lhs, rhs)
         self.template_params = {}
         self.process_rhs_params()

django/contrib/postgres/fields/array.py

@@ -135,6 +135,11 @@ def get_db_prep_value(self, value, connection, prepared=False):
             ]
         return value
 
+    def get_db_prep_save(self, value, connection):
+        if isinstance(value, (list, tuple)):
+            return [self.base_field.get_db_prep_save(i, connection) for i in value]
+        return value
+
     def deconstruct(self):
         name, path, args, kwargs = super().deconstruct()
         if path == "django.contrib.postgres.fields.array.ArrayField":

django/db/models/__init__.py

@@ -45,7 +45,7 @@
 from django.db.models.fields.composite import CompositePrimaryKey
 from django.db.models.fields.files import FileField, ImageField
 from django.db.models.fields.generated import GeneratedField
-from django.db.models.fields.json import JSONField
+from django.db.models.fields.json import JSONField, JSONNull
 from django.db.models.fields.proxy import OrderWrt
 from django.db.models.indexes import *  # NOQA
 from django.db.models.indexes import __all__ as indexes_all
@@ -97,6 +97,7 @@
     "ExpressionWrapper",
     "F",
     "Func",
+    "JSONNull",
     "OrderBy",
     "OuterRef",
     "RowRange",

django/db/models/fields/json.py

@@ -1,4 +1,5 @@
 import json
+import warnings
 
 from django import forms
 from django.core import checks, exceptions
@@ -11,6 +12,7 @@
     PostgresOperatorLookup,
     Transform,
 )
+from django.utils.deprecation import RemovedInDjango70Warning, django_file_prefixes
 from django.utils.translation import gettext_lazy as _
 
 from . import Field
@@ -148,6 +150,27 @@ def formfield(self, **kwargs):
         )
 
 
+class JSONNull(expressions.Value):
+    """Represent JSON `null` primitive."""
+
+    def __init__(self):
+        super().__init__(None, output_field=JSONField())
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}()"
+
+    def as_sql(self, compiler, connection):
+        value = self.output_field.get_db_prep_value(self.value, connection)
+        if value is None:
+            value = "null"
+        return "%s", (value,)
+
+    def as_mysql(self, compiler, connection):
+        sql, params = self.as_sql(compiler, connection)
+        sql = "JSON_EXTRACT(%s, '$')"
+        return sql, params
+
+
 class DataContains(FieldGetDbPrepValueMixin, PostgresOperatorLookup):
     lookup_name = "contains"
     postgres_operator = "@>"
@@ -311,14 +334,28 @@ def process_rhs(self, compiler, connection):
 
 
 class JSONExact(lookups.Exact):
+    # RemovedInDjango70Warning: When the deprecation period is over, remove
+    # the following line.
     can_use_none_as_rhs = True
 
     def process_rhs(self, compiler, connection):
+        if self.rhs is None and not isinstance(self.lhs, KeyTransform):
+            warnings.warn(
+                "Using None as the right-hand side of an exact lookup on JSONField to "
+                "mean JSON scalar 'null' is deprecated. Use JSONNull() instead (or use "
+                "the __isnull lookup if you meant SQL NULL).",
+                RemovedInDjango70Warning,
+                skip_file_prefixes=django_file_prefixes(),
+            )
+
         rhs, rhs_params = super().process_rhs(compiler, connection)
+
+        # RemovedInDjango70Warning: When the deprecation period is over, remove
+        # The following if-block entirely.
         # Treat None lookup values as null.
-        if rhs == "%s" and rhs_params == [None]:
-            rhs_params = ["null"]
-        if connection.vendor == "mysql":
+        if rhs == "%s" and (*rhs_params,) == (None,):
+            rhs_params = ("null",)
+        if connection.vendor == "mysql" and not isinstance(self.rhs, JSONNull):
             func = ["JSON_EXTRACT(%s, '$')"] * len(rhs_params)
             rhs %= tuple(func)
         return rhs, rhs_params
@@ -526,6 +563,10 @@ def resolve_expression_parameter(self, compiler, connection, sql, param):
 
 
 class KeyTransformExact(JSONExact):
+    # RemovedInDjango70Warning: When deprecation period ends, uncomment the
+    # flag below.
+    # can_use_none_as_rhs = True
+
     def process_rhs(self, compiler, connection):
         if isinstance(self.rhs, KeyTransform):
             return super(lookups.Exact, self).process_rhs(compiler, connection)
@@ -552,7 +593,7 @@ def process_rhs(self, compiler, connection):
 
     def as_oracle(self, compiler, connection):
         rhs, rhs_params = super().process_rhs(compiler, connection)
-        if rhs_params == ["null"]:
+        if rhs_params and (*rhs_params,) == ("null",):
             # Field has key and it's NULL.
             has_key_expr = HasKeyOrArrayIndex(self.lhs.lhs, self.lhs.key_name)
             has_key_sql, has_key_params = has_key_expr.as_oracle(compiler, connection)

django/db/models/lookups.py

@@ -232,12 +232,12 @@ def process_lhs(self, compiler, connection, lhs=None):
         lhs_sql = (
             connection.ops.lookup_cast(self.lookup_name, field_internal_type) % lhs_sql
         )
-        return lhs_sql, list(params)
+        return lhs_sql, tuple(params)
 
     def as_sql(self, compiler, connection):
         lhs_sql, params = self.process_lhs(compiler, connection)
         rhs_sql, rhs_params = self.process_rhs(compiler, connection)
-        params.extend(rhs_params)
+        params = (*params, *rhs_params)
         rhs_sql = self.get_rhs_op(connection, rhs_sql)
         return "%s %s" % (lhs_sql, rhs_sql), params
 
@@ -725,7 +725,7 @@ def as_sql(self, compiler, connection):
             rhs_sql, _ = self.process_rhs(compiler, connection)
             rhs_sql = self.get_direct_rhs_sql(connection, rhs_sql)
             start, finish = self.year_lookup_bounds(connection, self.rhs)
-            params.extend(self.get_bound_params(start, finish))
+            params = (*params, *self.get_bound_params(start, finish))
             return "%s %s" % (lhs_sql, rhs_sql), params
         return super().as_sql(compiler, connection)
 

django/db/models/sql/compiler.py

@@ -1703,8 +1703,8 @@ def field_as_sql(self, field, get_placeholder, val):
             sql, params = "%s", [val]
 
         # The following hook is only used by Oracle Spatial, which sometimes
-        # needs to yield 'NULL' and [] as its placeholder and params instead
-        # of '%s' and [None]. The 'NULL' placeholder is produced earlier by
+        # needs to yield 'NULL' and () as its placeholder and params instead
+        # of '%s' and (None,). The 'NULL' placeholder is produced earlier by
         # OracleOperations.get_geom_placeholder(). The following line removes
         # the corresponding None parameter. See ticket #10888.
         params = self.connection.ops.modify_insert_params(sql, params)

django/test/runner.py

@@ -1,6 +1,7 @@
 import argparse
 import ctypes
 import faulthandler
+import functools
 import hashlib
 import io
 import itertools
@@ -485,6 +486,16 @@ def _init_worker(
         )
 
 
+def _safe_init_worker(init_worker, counter, *args, **kwargs):
+    try:
+        init_worker(counter, *args, **kwargs)
+    except Exception:
+        with counter.get_lock():
+            # Set a value that will not increment above zero any time soon.
+            counter.value = -1000
+        raise
+
+
 def _run_subsuite(args):
     """
     Run a suite of tests with a RemoteTestRunner and return a RemoteTestResult.
@@ -558,7 +569,7 @@ def run(self, result):
         counter = multiprocessing.Value(ctypes.c_int, 0)
         pool = multiprocessing.Pool(
             processes=self.processes,
-            initializer=self.init_worker.__func__,
+            initializer=functools.partial(_safe_init_worker, self.init_worker.__func__),
             initargs=[
                 counter,
                 self.initial_settings,
@@ -585,7 +596,11 @@ def run(self, result):
 
             try:
                 subsuite_index, events = test_results.next(timeout=0.1)
-            except multiprocessing.TimeoutError:
+            except multiprocessing.TimeoutError as err:
+                if counter.value < 0:
+                    err.add_note("ERROR: _init_worker failed, see prior traceback")
+                    pool.close()
+                    raise
                 continue
             except StopIteration:
                 pool.close()

docs/faq/install.txt

@@ -25,10 +25,10 @@ needed.
 For a development environment -- if you just want to experiment with Django --
 you don't need to have a separate web server installed or database server.
 
-Django comes with its own :djadmin:`lightweight development server<runserver>`.
-For a production environment, Django follows the WSGI spec, :pep:`3333`, which
-means it can run on a variety of web servers. See :doc:`Deploying Django
-</howto/deployment/index>` for more information.
+Django comes with its own lightweight development server
+(:djadmin:`runserver`). For a production environment, Django follows the WSGI
+spec, :pep:`3333`, which means it can run on a variety of web servers. See
+:doc:`/howto/deployment/index` for more information.
 
 Django runs `SQLite`_ by default, which is included in Python installations.
 For a production environment, we recommend PostgreSQL_; but we also officially

docs/howto/error-reporting.txt

@@ -195,7 +195,7 @@ filtered out of error reports in a production environment (that is, where
 .. function:: sensitive_post_parameters(*parameters)
 
     If one of your views receives an :class:`~django.http.HttpRequest` object
-    with :attr:`POST parameters<django.http.HttpRequest.POST>` susceptible to
+    with :attr:`~django.http.HttpRequest.POST` parameters susceptible to
     contain sensitive information, you may prevent the values of those
     parameters from being included in the error reports using the
     ``sensitive_post_parameters`` decorator::

docs/howto/logging.txt

@@ -186,9 +186,9 @@ root of the project.
 Configure a formatter
 ~~~~~~~~~~~~~~~~~~~~~
 
-By default, the final log output contains the message part of each :class:`log
-record <logging.LogRecord>`. Use a formatter if you want to include additional
-data. First name and define your formatters - this example defines
+By default, the final log output contains the message part of each
+:class:`~logging.LogRecord` object. Use a formatter if you want to include
+additional data. First name and define your formatters - this example defines
 formatters named ``verbose`` and ``simple``:
 
 .. code-block:: python