BUG25726671: Fix compatibility issues with the latest Django versions

nmariz · nmariz · commit 6344aaab92b4 · 2017-06-06T11:28:59.000+01:00
This patch fixes some compatibility issues with the latest
Django versions.

The following bugs were also fixed:

BUG25349918: Add proxy methods for Django 1.9+ operations

- Methods for filtering time and datetime fields sql were
  changed in Django 1.9 from `value_to_db_datetime` to
  `adapt_datetimefield_value` and from `value_to_db_time`
  to `adapt_timefield_value`.
  Proxy methods were added to ensure compatibility.

BUG25349912: Bug fix for incorrect Django introspection type

- Removed extra encapsulation from get_constraints for
  foreign key parameter.

BUG25349897: Fix Django 1.9 bulk insert compatibility

- Added support for database backend API change introduced in
  Django 1.9 for `bulk_insert_sql` method.

Connector/Python now only supports Django 1.8+.

Test cases were added for regression.
diff --git a/lib/mysql/connector/django/introspection.py b/lib/mysql/connector/django/introspection.py
@@ -279,9 +279,8 @@ def get_constraints(self, cursor, table_name):
                     'unique': False,
                     'index': False,
                     'check': False,
-                    'foreign_key': (
-                        (ref_table, ref_column) if ref_column else None,
-                    )
+                    'foreign_key': \
+                        (ref_table, ref_column) if ref_column else None
                 }
             constraints[constraint]['columns'].add(column)
         # Now get the constraint types
diff --git a/lib/mysql/connector/django/operations.py b/lib/mysql/connector/django/operations.py
@@ -185,6 +185,10 @@ def validate_autopk_value(self, value):
                              'value for AutoField.')
         return value
 
+    if django.VERSION > (1, 8):
+        def adapt_datetimefield_value(self, value):
+            return self.value_to_db_datetime(value)
+
     def value_to_db_datetime(self, value):
         if value is None:
             return None
@@ -202,6 +206,10 @@ def value_to_db_datetime(self, value):
             return datetime_to_mysql(value)
         return self.connection.converter.to_mysql(value)
 
+    if django.VERSION > (1, 8):
+        def adapt_timefield_value(self, value):
+            return self.value_to_db_time(value)
+
     def value_to_db_time(self, value):
         if value is None:
             return None
@@ -218,9 +226,15 @@ def value_to_db_time(self, value):
     def max_name_length(self):
         return 64
 
-    def bulk_insert_sql(self, fields, num_values):
-        items_sql = "({0})".format(", ".join(["%s"] * len(fields)))
-        return "VALUES " + ", ".join([items_sql] * num_values)
+    if django.VERSION < (1, 9):
+        def bulk_insert_sql(self, fields, num_values):
+            items_sql = "({0})".format(", ".join(["%s"] * len(fields)))
+            return "VALUES " + ", ".join([items_sql] * num_values)
+    else:
+        def bulk_insert_sql(self, fields, placeholder_rows):
+            placeholder_rows_sql = (", ".join(row) for row in placeholder_rows)
+            values_sql = ", ".join("({0})".format(sql) for sql in placeholder_rows_sql)
+            return "VALUES " + values_sql
 
     if django.VERSION < (1, 8):
         def year_lookup_bounds(self, value):
diff --git a/tests/test_django.py b/tests/test_django.py
@@ -1,5 +1,5 @@
 # MySQL Connector/Python - MySQL driver written in Python.
-# Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved.
 
 # MySQL Connector/Python is licensed under the terms of the GPLv2
 # <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
@@ -60,6 +60,7 @@
             'TEST_COLLATION': 'utf8_general_ci',
             'CONN_MAX_AGE': 0,
             'AUTOCOMMIT': True,
+            'TIME_ZONE': None,
         },
     }
     settings.SECRET_KEY = "django_tests_secret_key"
@@ -92,15 +93,11 @@
 
 # Have to load django.db to make importing db backend work for Django < 1.6
 import django.db  # pylint: disable=W0611
-if tests.DJANGO_VERSION >= (1, 6):
-    if tests.DJANGO_VERSION >= (1, 8):
-        from django.db.backends.base.introspection import FieldInfo
-    else:
-        from django.db.backends import FieldInfo
 from django.db.backends.signals import connection_created
 from django.utils.safestring import SafeBytes, SafeText
 
 import mysql.connector
+from mysql.connector.django.introspection import FieldInfo
 
 if DJANGO_AVAILABLE:
     from mysql.connector.django.base import (
@@ -147,14 +144,14 @@ def tearDownClass(cls):
 
     def test_get_table_list(self):
         cur = self.cnx.cursor()
-        exp = list(TABLES.keys())
-        for exp in list(TABLES.keys()):
+        for exp in TABLES.keys():
             if sys.version_info < (2, 7):
                 self.assertTrue(exp in self.introspect.get_table_list(cur))
             else:
-                self.assertIn(exp, self.introspect.get_table_list(cur),
-                              "Table {table_name} not in table list".format(
-                                  table_name=exp))
+                res = any(table.name == exp
+                          for table in self.introspect.get_table_list(cur))
+                self.assertTrue(res, "Table {table_name} not in table list"
+                                     "".format(table_name=exp))
 
     def test_get_table_description(self):
         cur = self.cnx.cursor()
@@ -165,24 +162,39 @@ def test_get_table_description(self):
                 ('c1', 3, None, None, None, None, 1, 16392),
                 ('c2', 253, None, 20, None, None, 1, 16388)
             ]
-        else:
+        elif tests.DJANGO_VERSION < (1, 8):
             exp = [
-                FieldInfo(name='id', type_code=3, display_size=None,
+                FieldInfo(name=u'id', type_code=3, display_size=None,
                           internal_size=None, precision=None, scale=None,
                           null_ok=0),
-                FieldInfo(name='c1', type_code=3, display_size=None,
+                FieldInfo(name=u'c1', type_code=3, display_size=None,
                           internal_size=None, precision=None, scale=None,
                           null_ok=1),
-                FieldInfo(name='c2', type_code=253, display_size=None,
+                FieldInfo(name=u'c2', type_code=253, display_size=None,
                           internal_size=20, precision=None, scale=None,
                           null_ok=1)
             ]
+        else:
+            exp = [
+                FieldInfo(name=u'id', type_code=3, display_size=None,
+                          internal_size=None, precision=10, scale=None,
+                          null_ok=0, extra=u'auto_increment'),
+                FieldInfo(name=u'c1', type_code=3, display_size=None,
+                          internal_size=None, precision=10, scale=None,
+                          null_ok=1, extra=u''),
+                FieldInfo(name=u'c2', type_code=253, display_size=None,
+                          internal_size=20, precision=None, scale=None,
+                          null_ok=1, extra=u'')
+            ]
         res = self.introspect.get_table_description(cur, 'django_t1')
         self.assertEqual(exp, res)
 
     def test_get_relations(self):
         cur = self.cnx.cursor()
-        exp = {1: (0, 'django_t1')}
+        if tests.DJANGO_VERSION < (1, 8):
+            exp = {1: (0, 'django_t1')}
+        else:
+            exp = {u'id_t1': (u'id', u'django_t1')}
         self.assertEqual(exp, self.introspect.get_relations(cur, 'django_t2'))
 
     def test_get_key_columns(self):
@@ -204,6 +216,30 @@ def test_get_primary_key_column(self):
         res = self.introspect.get_primary_key_column(cur, 'django_t1')
         self.assertEqual('id', res)
 
+    def test_get_constraints(self):
+        cur = self.cnx.cursor()
+        exp = {
+            'PRIMARY': {'check': False,
+                        'columns': ['id'],
+                        'foreign_key': None,
+                        'index': True,
+                        'primary_key': True,
+                        'unique': True},
+            'django_t2_ibfk_1': {'check': False,
+                                 'columns': ['id_t1'],
+                                 'foreign_key': ('django_t1', 'id'),
+                                 'index': False,
+                                 'primary_key': False,
+                                 'unique': False},
+            'id_t1': {'check': False,
+                      'columns': ['id_t1'],
+                      'foreign_key': None,
+                      'index': True,
+                      'primary_key': False,
+                      'unique': False}
+        }
+        self.assertEqual(
+            exp, self.introspect.get_constraints(cur, 'django_t2'))
 
 @unittest.skipIf(not DJANGO_AVAILABLE, "Django not available")
 class DjangoDatabaseWrapper(tests.MySQLConnectorTests):
@@ -277,26 +313,49 @@ def setUp(self):
         self.dbo = DatabaseOperations(self.cnx)
 
     def test_value_to_db_time(self):
-        self.assertEqual(None, self.dbo.value_to_db_time(None))
+        if tests.DJANGO_VERSION < (1, 9):
+            value_to_db_time = self.dbo.value_to_db_time
+        else:
+            value_to_db_time = self.dbo.adapt_timefield_value
+
+        self.assertEqual(None, value_to_db_time(None))
 
         value = datetime.time(0, 0, 0)
         exp = self.conn.converter._time_to_mysql(value)
-        self.assertEqual(exp, self.dbo.value_to_db_time(value))
+        self.assertEqual(exp, value_to_db_time(value))
 
         value = datetime.time(2, 5, 7)
         exp = self.conn.converter._time_to_mysql(value)
-        self.assertEqual(exp, self.dbo.value_to_db_time(value))
+        self.assertEqual(exp, value_to_db_time(value))
 
     def test_value_to_db_datetime(self):
-        self.assertEqual(None, self.dbo.value_to_db_datetime(None))
+        if tests.DJANGO_VERSION < (1, 9):
+            value_to_db_datetime = self.dbo.value_to_db_datetime
+        else:
+            value_to_db_datetime = self.dbo.adapt_datetimefield_value
+
+        self.assertEqual(None, value_to_db_datetime(None))
 
         value = datetime.datetime(1, 1, 1)
         exp = self.conn.converter._datetime_to_mysql(value)
-        self.assertEqual(exp, self.dbo.value_to_db_datetime(value))
+        self.assertEqual(exp, value_to_db_datetime(value))
 
         value = datetime.datetime(2, 5, 7, 10, 10)
         exp = self.conn.converter._datetime_to_mysql(value)
-        self.assertEqual(exp, self.dbo.value_to_db_datetime(value))
+        self.assertEqual(exp, value_to_db_datetime(value))
+
+    def test_bulk_insert_sql(self):
+        num_values = 5
+        fields = ["col1", "col2", "col3"]
+        placeholder_rows = [["%s"] * len(fields) for _ in range(num_values)]
+        exp = "VALUES {0}".format(", ".join(
+            ["({0})".format(", ".join(["%s"] * len(fields)))] * num_values))
+        if tests.DJANGO_VERSION < (1, 9):
+            self.assertEqual(
+                exp, self.dbo.bulk_insert_sql(fields, num_values))
+        else:
+            self.assertEqual(
+                exp, self.dbo.bulk_insert_sql(fields, placeholder_rows))
 
 
 class DjangoMySQLConverterTests(tests.MySQLConnectorTests):
