BUG32947160: Remove MySQLdb module dependency from Django backend

MySQL Connector/Python extends the Django built-in MySQL backend, which
imports MySQLdb in base.py and introspection.py modules, and if it's not
installed an exception is raised mentioning that the module is missing.

This patch removes the need of using the built-ini MySQL base classes in
base.py and introspection.py, by implementing the missing methods.

Author: nmariz

CHANGES.txt

@@ -15,6 +15,7 @@ v8.0.26
 - WL#14542: Deprecate TLS 1.0 and 1.1
 - WL#14440: Support for authentication_kerberos_client authentication plugin
 - WL#14237: Support query attributes
+- BUG#32947160: Remove MySQLdb module dependency from Django backend
 - BUG#32789076: MSI is missing required libraries to use auth_ldap_client plugin
 - BUG#32778827: Raise an error if the _id is different when replacing a document
 - BUG#32740486: Fix typo in docstring

lib/mysql/connector/django/base.py

@@ -48,7 +48,6 @@
 from django.core.exceptions import ImproperlyConfigured
 from django.db import IntegrityError
 from django.db.backends.base.base import BaseDatabaseWrapper
-from django.db.backends.mysql.base import DatabaseWrapper as MySQLDatabaseWrapper
 from django.db import utils
 from django.utils.functional import cached_property
 from django.utils import dateparse, timezone
@@ -175,7 +174,7 @@ def __iter__(self):
         return iter(self.cursor)
 
 
-class DatabaseWrapper(MySQLDatabaseWrapper):
+class DatabaseWrapper(BaseDatabaseWrapper):
     vendor = 'mysql'
     # This dictionary maps Field objects to their associated MySQL column
     # types, as strings. Column-type strings can contain format strings; they'll
@@ -456,6 +455,30 @@ def data_type_check_constraints(self):
             return check_constraints
         return {}
 
+    @cached_property
+    def mysql_server_data(self):
+        with self.temporary_connection() as cursor:
+            # Select some server variables and test if the time zone
+            # definitions are installed. CONVERT_TZ returns NULL if 'UTC'
+            # timezone isn't loaded into the mysql.time_zone table.
+            cursor.execute("""
+                SELECT VERSION(),
+                       @@sql_mode,
+                       @@default_storage_engine,
+                       @@sql_auto_is_null,
+                       @@lower_case_table_names,
+                       CONVERT_TZ('2001-01-01 01:00:00', 'UTC', 'UTC') IS NOT NULL
+            """)
+            row = cursor.fetchone()
+        return {
+            'version': row[0],
+            'sql_mode': row[1],
+            'default_storage_engine': row[2],
+            'sql_auto_is_null': bool(row[3]),
+            'lower_case_table_names': bool(row[4]),
+            'has_zoneinfo_database': bool(row[5]),
+        }
+
     @cached_property
     def mysql_server_info(self):
         with self.temporary_connection() as cursor:
@@ -479,7 +502,6 @@ def sql_mode(self):
     @property
     def use_pure(self):
         return self._use_pure
-        # return not HAVE_CEXT or self._use_pure
 
 
 class DjangoMySQLConverter(MySQLConverter):

lib/mysql/connector/django/introspection.py

@@ -36,9 +36,6 @@
 from django.db.backends.base.introspection import (
     BaseDatabaseIntrospection, FieldInfo as BaseFieldInfo, TableInfo,
 )
-from django.db.backends.mysql.introspection import (
-    DatabaseIntrospection as MySQLDatabaseIntrospection,
-)
 from django.db.models import Index
 from django.utils.datastructures import OrderedSet
 
@@ -60,7 +57,57 @@
     )
 
 
-class DatabaseIntrospection(MySQLDatabaseIntrospection):
+class DatabaseIntrospection(BaseDatabaseIntrospection):
+
+    data_types_reverse = {
+        FieldType.BLOB: 'TextField',
+        FieldType.DECIMAL: 'DecimalField',
+        FieldType.NEWDECIMAL: 'DecimalField',
+        FieldType.DATE: 'DateField',
+        FieldType.DATETIME: 'DateTimeField',
+        FieldType.DOUBLE: 'FloatField',
+        FieldType.FLOAT: 'FloatField',
+        FieldType.INT24: 'IntegerField',
+        FieldType.LONG: 'IntegerField',
+        FieldType.LONGLONG: 'BigIntegerField',
+        FieldType.SHORT: 'SmallIntegerField',
+        FieldType.STRING: 'CharField',
+        FieldType.TIME: 'TimeField',
+        FieldType.TIMESTAMP: 'DateTimeField',
+        FieldType.TINY: 'IntegerField',
+        FieldType.TINY_BLOB: 'TextField',
+        FieldType.MEDIUM_BLOB: 'TextField',
+        FieldType.LONG_BLOB: 'TextField',
+        FieldType.VAR_STRING: 'CharField',
+    }
+
+    def get_field_type(self, data_type, description):
+        field_type = super().get_field_type(data_type, description)
+        if 'auto_increment' in description.extra:
+            if field_type == 'IntegerField':
+                return 'AutoField'
+            elif field_type == 'BigIntegerField':
+                return 'BigAutoField'
+            elif field_type == 'SmallIntegerField':
+                return 'SmallAutoField'
+        if description.is_unsigned:
+            if field_type == 'BigIntegerField':
+                return 'PositiveBigIntegerField'
+            elif field_type == 'IntegerField':
+                return 'PositiveIntegerField'
+            elif field_type == 'SmallIntegerField':
+                return 'PositiveSmallIntegerField'
+        # JSON data type is an alias for LONGTEXT in MariaDB, use check
+        # constraints clauses to introspect JSONField.
+        if description.has_json_constraint:
+            return 'JSONField'
+        return field_type
+
+    def get_table_list(self, cursor):
+        """Return a list of table and view names in the current database."""
+        cursor.execute("SHOW FULL TABLES")
+        return [TableInfo(row[0], {'BASE TABLE': 't', 'VIEW': 'v'}.get(row[1]))
+                for row in cursor.fetchall()]
 
     def get_table_description(self, cursor, table_name):
         """
@@ -181,6 +228,54 @@ def get_primary_key_column(self, cursor, table_name):
                 return column[0]
         return None
 
+    def get_sequences(self, cursor, table_name, table_fields=()):
+        for field_info in self.get_table_description(cursor, table_name):
+            if 'auto_increment' in field_info.extra:
+                # MySQL allows only one auto-increment column per table.
+                return [{'table': table_name, 'column': field_info.name}]
+        return []
+
+    def get_relations(self, cursor, table_name):
+        """
+        Return a dictionary of {field_name: (field_name_other_table, other_table)}
+        representing all relationships to the given table.
+        """
+        constraints = self.get_key_columns(cursor, table_name)
+        relations = {}
+        for my_fieldname, other_table, other_field in constraints:
+            relations[my_fieldname] = (other_field, other_table)
+        return relations
+
+    def get_key_columns(self, cursor, table_name):
+        """
+        Return a list of (column_name, referenced_table_name, referenced_column_name)
+        for all key columns in the given table.
+        """
+        key_columns = []
+        cursor.execute("""
+            SELECT column_name, referenced_table_name, referenced_column_name
+            FROM information_schema.key_column_usage
+            WHERE table_name = %s
+                AND table_schema = DATABASE()
+                AND referenced_table_name IS NOT NULL
+                AND referenced_column_name IS NOT NULL""", [table_name])
+        key_columns.extend(cursor.fetchall())
+        return key_columns
+
+    def get_storage_engine(self, cursor, table_name):
+        """
+        Retrieve the storage engine for a given table. Return the default
+        storage engine if the table doesn't exist.
+        """
+        cursor.execute(
+            "SELECT engine "
+            "FROM information_schema.tables "
+            "WHERE table_name = %s", [table_name])
+        result = cursor.fetchone()
+        if not result:
+            return self.connection.features._mysql_storage_engine
+        return result[0]
+
     def get_constraints(self, cursor, table_name):
         """
         Retrieve any constraints or keys (unique, pk, fk, check, index) across