Add capability to convert to and from AutoField and BigAutoField (#128)

* Add support for AutoField BigAutoField migration

* Re-adding unit tests for autofield conversions

* Check added for identity field conversions. Typo fix delete query.

Author: sg3-141-592

mssql/schema.py

@@ -69,20 +69,20 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
     sql_delete_column = "ALTER TABLE %(table)s DROP COLUMN %(column)s"
     sql_delete_index = "DROP INDEX %(name)s ON %(table)s"
     sql_delete_table = """
-        DECLARE @sql_froeign_constraint_name nvarchar(128)
+        DECLARE @sql_foreign_constraint_name nvarchar(128)
         DECLARE @sql_drop_constraint nvarchar(300)
         WHILE EXISTS(SELECT 1
             FROM sys.foreign_keys
             WHERE referenced_object_id = object_id('%(table)s'))
         BEGIN
-            SELECT TOP 1 @sql_froeign_constraint_name = name
+            SELECT TOP 1 @sql_foreign_constraint_name = name
             FROM sys.foreign_keys
             WHERE referenced_object_id = object_id('%(table)s')
             SELECT
             @sql_drop_constraint = 'ALTER TABLE [' + OBJECT_NAME(parent_object_id) + '] ' +
-            'DROP CONSTRAINT [' + @sql_froeign_constraint_name + '] '
+            'DROP CONSTRAINT [' + @sql_foreign_constraint_name + '] '
             FROM sys.foreign_keys
-            WHERE referenced_object_id = object_id('%(table)s') and name = @sql_froeign_constraint_name
+            WHERE referenced_object_id = object_id('%(table)s') and name = @sql_foreign_constraint_name
             exec sp_executesql @sql_drop_constraint
         END
         DROP TABLE %(table)s
@@ -283,11 +283,19 @@ def _alter_field(self, model, old_field, new_field, old_type, new_type,
                      old_db_params, new_db_params, strict=False):
         """Actually perform a "physical" (non-ManyToMany) field update."""
 
-        # the backend doesn't support altering from/to (Big)AutoField
-        # because of the limited capability of SQL Server to edit IDENTITY property
+        # the backend doesn't support altering a column to/from AutoField as
+        # SQL Server cannot alter columns to add and remove IDENTITY properties
+        old_is_auto = False
+        new_is_auto = False
         for t in (AutoField, BigAutoField):
-            if isinstance(old_field, t) or isinstance(new_field, t):
-                raise NotImplementedError("the backend doesn't support altering from/to %s." % t.__name__)
+            if isinstance(old_field, t):
+                old_is_auto = True
+            if isinstance(new_field, t):
+                new_is_auto = True
+        if (old_is_auto and not new_is_auto) or (not old_is_auto and new_is_auto):
+            raise NotImplementedError("the backend doesn't support altering from %s to %s." %
+                (old_field.get_internal_type(), new_field.get_internal_type()))
+        
         # Drop any FK constraints, we'll remake them later
         fks_dropped = set()
         if old_field.remote_field and old_field.db_constraint:
@@ -327,6 +335,17 @@ def _alter_field(self, model, old_field, new_field, old_type, new_type,
                 )
                 for fk_name in rel_fk_names:
                     self.execute(self._delete_constraint_sql(self.sql_delete_fk, new_rel.related_model, fk_name))
+        # If working with an AutoField or BigAutoField drop all indexes on the related table
+        # This is needed when doing ALTER column statements on IDENTITY fields
+        # https://stackoverflow.com/questions/33429775/sql-server-alter-table-alter-column-giving-set-option-error
+        for t in (AutoField, BigAutoField):
+            if isinstance(old_field, t) or isinstance(new_field, t):
+                index_names = self._constraint_names(model, index=True)
+                for index_name in index_names:
+                    self.execute(
+                        self._delete_constraint_sql(self.sql_delete_index, model, index_name)
+                    )
+                break
         # Removed an index? (no strict check, as multiple indexes are possible)
         # Remove indexes if db_index switched to False or a unique constraint
         # will now be used in lieu of an index. The following lines from the
@@ -542,7 +561,8 @@ def _alter_field(self, model, old_field, new_field, old_type, new_type,
             # Restore unique constraints
             # Note: if nullable they are implemented via an explicit filtered UNIQUE INDEX (not CONSTRAINT)
             # in order to get ANSI-compliant NULL behaviour (i.e. NULL != NULL, multiple are allowed)
-            if old_field.unique and new_field.unique:
+            # Note: Don't restore primary keys, we need to re-create those seperately
+            if old_field.unique and new_field.unique and not new_field.primary_key:
                 if new_field.null:
                     self.execute(
                         self._create_index_sql(
@@ -568,7 +588,47 @@ def _alter_field(self, model, old_field, new_field, old_type, new_type,
                         if old_field.column in columns:
                             condition = ' AND '.join(["[%s] IS NOT NULL" % col for col in columns])
                             self.execute(self._create_unique_sql(model, columns, condition=condition))
+            # Restore primary keys
+            if old_field.primary_key and new_field.primary_key:
+                self.execute(
+                    self.sql_create_pk % {
+                        "table": self.quote_name(model._meta.db_table),
+                        "name": self.quote_name(
+                            self._create_index_name(model._meta.db_table, [new_field.column], suffix="_pk")
+                        ),
+                        "columns": self.quote_name(new_field.column),
+                    }
+                )
+            # Restore unqiue_together
+            # If we have ALTERed an AutoField or BigAutoField we need to recreate all unique_together clauses
+            for t in (AutoField, BigAutoField):
+                if isinstance(old_field, t) or isinstance(new_field, t):
+                    for field_names in model._meta.unique_together:
+                        columns = [model._meta.get_field(field).column for field in field_names]
+                        fields = [model._meta.get_field(field) for field in field_names]
+                        condition = ' AND '.join(["[%s] IS NOT NULL" % col for col in columns])
+                        # We need to pass fields instead of columns when using >= Django 4.0 because
+                        # of a backwards incompatible change to _create_unique_sql
+                        if django_version >= (4, 0):
+                            self.execute(
+                                self._create_unique_sql(model, fields, condition=condition)
+                            )
+                        else:
+                            self.execute(
+                                self._create_unique_sql(model, columns, condition=condition)
+                            )
+                    break
+
             # Restore indexes
+            # If we have ALTERed an AutoField or BigAutoField we need to recreate all indexes
+            for t in (AutoField, BigAutoField):
+                if isinstance(old_field, t) or isinstance(new_field, t):
+                    for field in model._meta.fields:
+                        if field.db_index:
+                            self.execute(
+                                self._create_index_sql(model, [field])
+                            )
+                    break
             index_columns = []
             if old_field.db_index and new_field.db_index:
                 index_columns.append([old_field])
@@ -626,7 +686,26 @@ def _alter_field(self, model, old_field, new_field, old_type, new_type,
             for sql, params in other_actions:
                 self.execute(sql, params)
             # Restore related_model indexes
-            self.execute(self._create_index_sql(new_rel.related_model, [new_rel.field]))
+            for field in new_rel.related_model._meta.fields:
+                if field.db_index:
+                    self.execute(
+                        self._create_index_sql(new_rel.related_model, [field])
+                    )
+            # Restore unique_together clauses
+            for field_names in new_rel.related_model._meta.unique_together:
+                columns = [new_rel.related_model._meta.get_field(field).column for field in field_names]
+                fields = [new_rel.related_model._meta.get_field(field) for field in field_names]
+                condition = ' AND '.join(["[%s] IS NOT NULL" % col for col in columns])
+                # We need to pass fields instead of columns when using >= Django 4.0 because
+                # of a backwards incompatible change to _create_unique_sql
+                if django_version >= (4, 0):
+                    self.execute(
+                        self._create_unique_sql(new_rel.related_model, fields, condition=condition)
+                    )
+                else:
+                    self.execute(
+                        self._create_unique_sql(new_rel.related_model, columns, condition=condition)
+                    )
         # Does it have a foreign key?
         if (new_field.remote_field and
                 (fks_dropped or not old_field.remote_field or not old_field.db_constraint) and

testapp/migrations/0020_autofield_to_bigautofield.py

@@ -0,0 +1,18 @@
+# Generated by Django 3.2.13 on 2022-05-04 01:36
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('testapp', '0019_customer_name_customer_address'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='author',
+            name='id',
+            field=models.BigAutoField(primary_key=True, serialize=False),
+        ),
+    ]

testapp/migrations/0021_multiple_autofield_to_bigauto.py

@@ -0,0 +1,28 @@
+# Generated by Django 3.2.13 on 2022-05-04 01:37
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('testapp', '0020_autofield_to_bigautofield'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='author',
+            name='id',
+            field=models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID'),
+        ),
+        migrations.AlterField(
+            model_name='editor',
+            name='id',
+            field=models.BigAutoField(primary_key=True, serialize=False),
+        ),
+        migrations.AlterField(
+            model_name='post',
+            name='id',
+            field=models.BigAutoField(primary_key=True, serialize=False),
+        ),
+    ]

testapp/models.py

@@ -9,16 +9,22 @@
 from django.db.models import Q
 from django.utils import timezone
 
+# We are using this Mixin to test casting of BigAuto and Auto fields 
+class BigAutoFieldMixin(models.Model):
+    id = models.BigAutoField(primary_key=True)
+
+    class Meta:
+        abstract = True
 
 class Author(models.Model):
     name = models.CharField(max_length=100)
 
 
-class Editor(models.Model):
+class Editor(BigAutoFieldMixin, models.Model):
     name = models.CharField(max_length=100)
 
 
-class Post(models.Model):
+class Post(BigAutoFieldMixin, models.Model):
     title = models.CharField('title', max_length=255)
     author = models.ForeignKey(Author, models.CASCADE)
     # Optional secondary author

testapp/settings.py

@@ -124,7 +124,6 @@
     'migrations.test_operations.OperationTests.test_add_constraint_percent_escaping',
     'migrations.test_operations.OperationTests.test_alter_field_pk',
     'migrations.test_operations.OperationTests.test_alter_field_reloads_state_on_fk_with_to_field_target_changes',
-    'migrations.test_operations.OperationTests.test_autofield_foreignfield_growth',
     'schema.tests.SchemaTests.test_alter_auto_field_to_char_field',
     'schema.tests.SchemaTests.test_alter_auto_field_to_integer_field',
     'schema.tests.SchemaTests.test_alter_implicit_id_to_explicit',
@@ -198,15 +197,9 @@
     'expressions.tests.FTimeDeltaTests.test_time_subquery_subtraction',
     'expressions.tests.BasicExpressionsTests.test_filtering_on_q_that_is_boolean',
     'migrations.test_operations.OperationTests.test_alter_field_reloads_state_on_fk_with_to_field_target_type_change',
-    'migrations.test_operations.OperationTests.test_autofield__bigautofield_foreignfield_growth',
-    'migrations.test_operations.OperationTests.test_smallfield_autofield_foreignfield_growth',
-    'migrations.test_operations.OperationTests.test_smallfield_bigautofield_foreignfield_growth',
-    'schema.tests.SchemaTests.test_alter_auto_field_quoted_db_column',
-    'schema.tests.SchemaTests.test_alter_autofield_pk_to_bigautofield_pk_sequence_owner',
-    'schema.tests.SchemaTests.test_alter_autofield_pk_to_smallautofield_pk_sequence_owner',
     'schema.tests.SchemaTests.test_alter_primary_key_quoted_db_table',
     'schema.tests.SchemaTests.test_alter_smallint_pk_to_smallautofield_pk',
-
+    
     'annotations.tests.NonAggregateAnnotationTestCase.test_combined_expression_annotation_with_aggregation',
     'db_functions.comparison.test_cast.CastTests.test_cast_to_integer',
     'db_functions.datetime.test_extract_trunc.DateFunctionTests.test_extract_func',