BUG#34127959: Add isolation level support in Django backend

When running concurrent loads, database transactions from different
sessions may interact with each other. These interactions are affected
by each session's transaction isolation level.

This patch allows setting in the Django settings.py the connection
isolation level with an 'isolation_level' entry in the OPTIONS part of
the database configuration in DATABASES.

Change-Id: If582da767a95692658a82e2af79f3cc6e35936bd

Author: nmariz

Diff for: CHANGES.txt

@@ -16,6 +16,7 @@ v8.0.30
 - WL#15035: Enforce PEP 7 and PEP 8 coding style
 - WL#14822: Refactor the authentication plugin mechanism
 - WL#14815: Support OpenSSL 3.0
+- BUG#34127959: Add isolation level support in Django backend
 - BUG#33923516: Allow tuple of dictionaries as "failover" argument
 - BUG#28821983: Fix rounding errors for decimal values
 

Diff for: lib/mysql/connector/django/base.py

@@ -266,6 +266,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         "iendswith": "LIKE CONCAT('%%', {})",
     }
 
+    isolation_level = None
     isolation_levels = {
         "read uncommitted",
         "read committed",
@@ -338,12 +339,25 @@ def get_connection_params(self):
             # Need potentially affected rows on UPDATE
             mysql.connector.constants.ClientFlag.FOUND_ROWS,
         ]
+
         try:
-            kwargs.update(settings_dict["OPTIONS"])
+            options = settings_dict["OPTIONS"].copy()
+            isolation_level = options.pop("isolation_level")
+            if isolation_level:
+                isolation_level = isolation_level.lower()
+                if isolation_level not in self.isolation_levels:
+                    valid_levels = ", ".join(
+                        f"'{level}'" for level in sorted(self.isolation_levels)
+                    )
+                    raise ImproperlyConfigured(
+                        f"Invalid transaction isolation level '{isolation_level}' "
+                        f"specified.\nUse one of {valid_levels}, or None."
+                    )
+            self.isolation_level = isolation_level
+            kwargs.update(options)
         except KeyError:
             # OPTIONS missing is OK
             pass
-
         return kwargs
 
     def get_new_connection(self, conn_params):
@@ -362,6 +376,12 @@ def init_connection_state(self):
             # with SQL standards.
             assignments.append("SET SQL_AUTO_IS_NULL = 0")
 
+        if self.isolation_level:
+            assignments.append(
+                "SET SESSION TRANSACTION ISOLATION LEVEL "
+                f"{self.isolation_level.upper()}"
+            )
+
         if assignments:
             with self.cursor() as cursor:
                 cursor.execute("; ".join(assignments))
@@ -565,7 +585,7 @@ def _datetime_to_python(value, dsc=None):
         if not value:
             return None
 
-        dt = super()._datetime_to_python(value)
+        dt = MySQLConverter._datetime_to_python(value)
         if dt is None:
             return None
         if settings.USE_TZ and timezone.is_naive(dt):

Diff for: tests/test_django.py

@@ -103,6 +103,8 @@
 # Have to load django.db to make importing db backend work for Django < 1.6
 import django.db  # pylint: disable=W0611
 
+from django.core.exceptions import ImproperlyConfigured
+from django.db import connection
 from django.db.backends.signals import connection_created
 from django.db.utils import DEFAULT_DB_ALIAS, load_backend
 from django.utils.safestring import SafeText
@@ -122,6 +124,37 @@
     from mysql.connector.django.introspection import DatabaseIntrospection
 
 
+@unittest.skipIf(not DJANGO_AVAILABLE, "Django not available")
+class DjangoSettings(tests.MySQLConnectorTests):
+    """Test the Django settings."""
+
+    def test_get_connection_params(self):
+        config = tests.get_mysql_config()
+        settings_dict = connection.settings_dict.copy()
+
+        # The default isolation_level should be None
+        database_wrapper = DatabaseWrapper(settings_dict)
+        self.assertIsNone(database_wrapper.isolation_level)
+
+        # An invalid isolation_level should raise ImproperlyConfigured
+        settings_dict["OPTIONS"]["isolation_level"] = "invalid_level"
+        with self.assertRaises(ImproperlyConfigured):
+            _ = DatabaseWrapper(settings_dict).get_connection_params()
+
+        # Test a valid isolation_level
+        settings_dict["OPTIONS"]["isolation_level"] = "read committed"
+        database_wrapper = DatabaseWrapper(settings_dict)
+        connection_params = database_wrapper.get_connection_params()
+        self.assertEqual(database_wrapper.isolation_level, "read committed")
+        self.assertEqual(connection_params["database"], config["database"])
+
+        # Test session isolation level integration
+        with database_wrapper.cursor() as cur:
+            cur.execute("SELECT @@transaction_isolation")
+            res = cur.fetchall()
+            self.assertEqual(res[0][0], "READ-COMMITTED")
+
+
 @unittest.skipIf(not DJANGO_AVAILABLE, "Django not available")
 class DjangoIntrospection(tests.MySQLConnectorTests):
     """Test the Django introspection module"""