BUG32435181: Add support for Django 3.2

This patch adds support for Django 3.2, maintaining backward compatibility
with Django 2.2, 3.0 and 3.1.

Tests got adjusted for regression.

Author: nmariz

CHANGES.txt

@@ -15,6 +15,7 @@ v8.0.24
 - WL#14239: Remove Python 2.7 support
 - WL#14212: Support connection close notification
 - WL#14027: Add support for Python 3.9
+- BUG#32435181: Add support for Django 3.2
 - BUG#32029891: Add context manager support for pooled connections
 
 v8.0.23

lib/mysql/connector/django/base.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2020, Oracle and/or its affiliates.
+# Copyright (c) 2020, 2021, Oracle and/or its affiliates.
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License, version 2.0, as
@@ -48,6 +48,7 @@
 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
@@ -174,7 +175,7 @@ def __iter__(self):
         return iter(self.cursor)
 
 
-class DatabaseWrapper(BaseDatabaseWrapper):
+class DatabaseWrapper(MySQLDatabaseWrapper):
     vendor = 'mysql'
     # This dictionary maps Field objects to their associated MySQL column
     # types, as strings. Column-type strings can contain format strings; they'll

lib/mysql/connector/django/introspection.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2020, Oracle and/or its affiliates.
+# Copyright (c) 2020, 2021, Oracle and/or its affiliates.
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License, version 2.0, as
@@ -32,101 +32,84 @@
 
 from mysql.connector.constants import FieldType
 
+from django import VERSION as DJANGO_VERSION
 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
 
-FieldInfo = namedtuple('FieldInfo', BaseFieldInfo._fields + ('extra', 'is_unsigned', 'has_json_constraint'))
-InfoLine = namedtuple('InfoLine', 'col_name data_type max_len num_prec num_scale extra column_default is_unsigned')
-
-
-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.JSON: 'JSONField',
-        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',
-    }
+FieldInfo = namedtuple(
+    'FieldInfo',
+    BaseFieldInfo._fields + ('extra', 'is_unsigned', 'has_json_constraint')
+)
+if DJANGO_VERSION < (3, 2, 0):
+    InfoLine = namedtuple(
+        'InfoLine',
+        'col_name data_type max_len num_prec num_scale extra column_default '
+        'is_unsigned'
+    )
+else:
+    InfoLine = namedtuple(
+        'InfoLine',
+        'col_name data_type max_len num_prec num_scale extra column_default '
+        'collation is_unsigned'
+    )
 
-    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()]
+class DatabaseIntrospection(MySQLDatabaseIntrospection):
 
     def get_table_description(self, cursor, table_name):
         """
         Return a description of the table with the DB-API cursor.description
         interface."
         """
         json_constraints = {}
-        if self.connection.mysql_is_mariadb and self.connection.features.can_introspect_json_field:
-            # JSON data type is an alias for LONGTEXT in MariaDB, select
-            # JSON_VALID() constraints to introspect JSONField.
-            cursor.execute("""
-                SELECT c.constraint_name AS column_name
-                FROM information_schema.check_constraints AS c
-                WHERE
-                    c.table_name = %s AND
-                    LOWER(c.check_clause) = 'json_valid(`' + LOWER(c.constraint_name) + '`)' AND
-                    c.constraint_schema = DATABASE()
-            """, [table_name])
-            json_constraints = {row[0] for row in cursor.fetchall()}
+        # A default collation for the given table.
+        cursor.execute("""
+            SELECT  table_collation
+            FROM    information_schema.tables
+            WHERE   table_schema = DATABASE()
+            AND     table_name = %s
+        """, [table_name])
+        row = cursor.fetchone()
+        default_column_collation = row[0] if row else ''
         # information_schema database gives more accurate results for some figures:
         # - varchar length returned by cursor.description is an internal length,
         #   not visible length (#5725)
         # - precision and scale (for decimal fields) (#5014)
         # - auto_increment is not available in cursor.description
-        cursor.execute("""
-            SELECT
-                column_name, data_type, character_maximum_length,
-                numeric_precision, numeric_scale, extra, column_default,
-                CASE
-                    WHEN column_type LIKE '%% unsigned' THEN 1
-                    ELSE 0
-                END AS is_unsigned
-            FROM information_schema.columns
-            WHERE table_name = %s AND table_schema = DATABASE()""", [table_name])
+        if DJANGO_VERSION < (3, 2, 0):
+            cursor.execute("""
+                SELECT
+                    column_name, data_type, character_maximum_length,
+                    numeric_precision, numeric_scale, extra, column_default,
+                    CASE
+                        WHEN column_type LIKE '%% unsigned' THEN 1
+                        ELSE 0
+                    END AS is_unsigned
+                FROM information_schema.columns
+                WHERE table_name = %s AND table_schema = DATABASE()
+            """, [table_name])
+        else:
+            cursor.execute("""
+                SELECT
+                    column_name, data_type, character_maximum_length,
+                    numeric_precision, numeric_scale, extra, column_default,
+                    CASE
+                        WHEN collation_name = %s THEN NULL
+                        ELSE collation_name
+                    END AS collation_name,
+                    CASE
+                        WHEN column_type LIKE '%% unsigned' THEN 1
+                        ELSE 0
+                    END AS is_unsigned
+                FROM information_schema.columns
+                WHERE table_name = %s AND table_schema = DATABASE()
+            """, [default_column_collation, table_name])
         field_info = {line[0]: InfoLine(*line) for line in cursor.fetchall()}
 
         cursor.execute("SELECT * FROM %s LIMIT 1" % self.connection.ops.quote_name(table_name))
@@ -137,56 +120,33 @@ def to_int(i):
         fields = []
         for line in cursor.description:
             info = field_info[line[0]]
-            name, type_code, display_size = line[:3]
-            fields.append(FieldInfo(
-                name,
-                type_code,
-                display_size,
-                to_int(info.max_len) or line[3],
-                to_int(info.num_prec) or line[4],
-                to_int(info.num_scale) or line[5],
-                line[6],
-                info.column_default,
-                info.extra,
-                info.is_unsigned,
-                line[0] in json_constraints
-            ))
+            if DJANGO_VERSION < (3, 2, 0):
+                fields.append(FieldInfo(
+                    *line[:3],
+                    to_int(info.max_len) or line[3],
+                    to_int(info.num_prec) or line[4],
+                    to_int(info.num_scale) or line[5],
+                    line[6],
+                    info.column_default,
+                    info.extra,
+                    info.is_unsigned,
+                    line[0] in json_constraints
+                ))
+            else:
+                fields.append(FieldInfo(
+                    *line[:3],
+                    to_int(info.max_len) or line[3],
+                    to_int(info.num_prec) or line[4],
+                    to_int(info.num_scale) or line[5],
+                    line[6],
+                    info.column_default,
+                    info.collation,
+                    info.extra,
+                    info.is_unsigned,
+                    line[0] in json_constraints,
+                ))
         return fields
 
-    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_indexes(self, cursor, table_name):
         cursor.execute("SHOW INDEX FROM {0}"
                        "".format(self.connection.ops.quote_name(table_name)))
@@ -221,33 +181,6 @@ def get_primary_key_column(self, cursor, table_name):
                 return column[0]
         return None
 
-    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 _parse_constraint_columns(self, check_clause, columns):
-        check_columns = OrderedSet()
-        statement = sqlparse.parse(check_clause)[0]
-        tokens = (token for token in statement.flatten() if not token.is_whitespace)
-        for token in tokens:
-            if (
-                token.ttype == sqlparse.tokens.Name and
-                self.connection.ops.quote_name(token.value) == token.value and
-                token.value[1:-1] in columns
-            ):
-                check_columns.add(token.value[1:-1])
-        return check_columns
-
     def get_constraints(self, cursor, table_name):
         """
         Retrieve any constraints or keys (unique, pk, fk, check, index) across
@@ -275,6 +208,8 @@ def get_constraints(self, cursor, table_name):
                     'check': False,
                     'foreign_key': (ref_table, ref_column) if ref_column else None,
                 }
+                if self.connection.features.supports_index_column_ordering:
+                    constraints[constraint]['orders'] = []
             constraints[constraint]['columns'].add(column)
         # Now get the constraint types
         type_query = """
@@ -295,27 +230,18 @@ def get_constraints(self, cursor, table_name):
         if self.connection.features.can_introspect_check_constraints:
             unnamed_constraints_index = 0
             columns = {info.name for info in self.get_table_description(cursor, table_name)}
-            if self.connection.mysql_is_mariadb:
-                type_query = """
-                    SELECT c.constraint_name, c.check_clause
-                    FROM information_schema.check_constraints AS c
-                    WHERE
-                        c.constraint_schema = DATABASE() AND
-                        c.table_name = %s
-                """
-            else:
-                type_query = """
-                    SELECT cc.constraint_name, cc.check_clause
-                    FROM
-                        information_schema.check_constraints AS cc,
-                        information_schema.table_constraints AS tc
-                    WHERE
-                        cc.constraint_schema = DATABASE() AND
-                        tc.table_schema = cc.constraint_schema AND
-                        cc.constraint_name = tc.constraint_name AND
-                        tc.constraint_type = 'CHECK' AND
-                        tc.table_name = %s
-                """
+            type_query = """
+                SELECT cc.constraint_name, cc.check_clause
+                FROM
+                    information_schema.check_constraints AS cc,
+                    information_schema.table_constraints AS tc
+                WHERE
+                    cc.constraint_schema = DATABASE() AND
+                    tc.table_schema = cc.constraint_schema AND
+                    cc.constraint_name = tc.constraint_name AND
+                    tc.constraint_type = 'CHECK' AND
+                    tc.table_name = %s
+            """
             cursor.execute(type_query, [table_name])
             for constraint, check_clause in cursor.fetchall():
                 constraint_columns = self._parse_constraint_columns(check_clause, columns)
@@ -335,7 +261,9 @@ def get_constraints(self, cursor, table_name):
                 }
         # Now add in the indexes
         cursor.execute("SHOW INDEX FROM %s" % self.connection.ops.quote_name(table_name))
-        for table, non_unique, index, colseq, column, type_ in [x[:5] + (x[10],) for x in cursor.fetchall()]:
+        for table, non_unique, index, colseq, column, order, type_ in [
+            x[:6] + (x[10],) for x in cursor.fetchall()
+        ]:
             if index not in constraints:
                 constraints[index] = {
                     'columns': OrderedSet(),
@@ -344,9 +272,13 @@ def get_constraints(self, cursor, table_name):
                     'check': False,
                     'foreign_key': None,
                 }
+                if self.connection.features.supports_index_column_ordering:
+                    constraints[index]['orders'] = []
             constraints[index]['index'] = True
             constraints[index]['type'] = Index.suffix if type_ == 'BTREE' else type_.lower()
             constraints[index]['columns'].add(column)
+            if self.connection.features.supports_index_column_ordering:
+                constraints[index]['orders'].append('DESC' if order == 'D' else 'ASC')
         # Convert the sorted sets to lists
         for constraint in constraints.values():
             constraint['columns'] = list(constraint['columns'])