diff --git a/django/db/backends/mysql/introspection.py b/django/db/backends/mysql/introspection.py index 022e3b74cb..310f270a0b 100644 --- a/django/db/backends/mysql/introspection.py +++ b/django/db/backends/mysql/introspection.py @@ -99,7 +99,12 @@ class DatabaseIntrospection(BaseDatabaseIntrospection): for row in rows: if row[2] in multicol_indexes: continue - indexes[row[4]] = {'primary_key': (row[2] == 'PRIMARY'), 'unique': not bool(row[1])} + if row[4] not in indexes: + indexes[row[4]] = {'primary_key': False, 'unique': False} + if row[2] == 'PRIMARY': + indexes[row[4]]['primary_key'] = True + if not bool(row[1]): + indexes[row[4]]['unique'] = True return indexes def get_constraints(self, cursor, table_name): diff --git a/django/db/backends/mysql/schema.py b/django/db/backends/mysql/schema.py index c5c2e5cf1f..08e883d80c 100644 --- a/django/db/backends/mysql/schema.py +++ b/django/db/backends/mysql/schema.py @@ -21,3 +21,6 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor): alter_string_set_null = 'MODIFY %(column)s %(type)s NULL;' alter_string_drop_null = 'MODIFY %(column)s %(type)s NOT NULL;' + + sql_create_pk = "ALTER TABLE %(table)s ADD CONSTRAINT %(name)s PRIMARY KEY (%(columns)s)" + sql_delete_pk = "ALTER TABLE %(table)s DROP PRIMARY KEY" diff --git a/django/db/backends/schema.py b/django/db/backends/schema.py index 88fc4b7e62..ae80f60c30 100644 --- a/django/db/backends/schema.py +++ b/django/db/backends/schema.py @@ -24,8 +24,6 @@ class BaseDatabaseSchemaEditor(object): - Repointing of FKs - Repointing of M2Ms - Check constraints (PosIntField) - - PK changing - - db_index on alter field """ # Overrideable SQL templates @@ -57,8 +55,8 @@ class BaseDatabaseSchemaEditor(object): sql_create_index = "CREATE INDEX %(name)s ON %(table)s (%(columns)s)%(extra)s;" sql_delete_index = "DROP INDEX %(name)s" - sql_create_pk = "ALTER TABLE %(table)s ADD CONSTRAINT %(constraint)s PRIMARY KEY (%(columns)s)" - sql_delete_pk = "ALTER TABLE %(table)s DROP CONSTRAINT %(constraint)s" + sql_create_pk = "ALTER TABLE %(table)s ADD CONSTRAINT %(name)s PRIMARY KEY (%(columns)s)" + sql_delete_pk = "ALTER TABLE %(table)s DROP CONSTRAINT %(name)s" def __init__(self, connection): self.connection = connection @@ -135,9 +133,10 @@ class BaseDatabaseSchemaEditor(object): elif field.unique: sql += " UNIQUE" # If we were told to include a default value, do so - if include_default: + default_value = self.effective_default(field) + if include_default and default_value is not None: sql += " DEFAULT %s" - params += [self.effective_default(field)] + params += [default_value] # Return the sql return sql, params @@ -491,6 +490,32 @@ class BaseDatabaseSchemaEditor(object): "extra": "", } ) + # Changed to become primary key? + # Note that we don't detect unsetting of a PK, as we assume another field + # will always come along and replace it. + if not old_field.primary_key and new_field.primary_key: + # First, drop the old PK + constraint_names = self._constraint_names(model, primary_key=True) + if strict and len(constraint_names) != 1: + raise ValueError("Found wrong number (%s) of PK constraints for %s" % ( + len(constraint_names), + model._meta.db_table, + )) + for constraint_name in constraint_names: + self.execute( + self.sql_delete_pk % { + "table": self.quote_name(model._meta.db_table), + "name": constraint_name, + }, + ) + # Make the new one + self.execute( + self.sql_create_pk % { + "table": self.quote_name(model._meta.db_table), + "name": self._create_index_name(model, [new_field.column], suffix="_pk"), + "columns": self.quote_name(new_field.column), + } + ) def _type_for_alter(self, field): """ @@ -518,16 +543,16 @@ class BaseDatabaseSchemaEditor(object): index_name = '%s%s' % (table_name[:(self.connection.features.max_index_name_length - len(part))], part) return index_name - def _constraint_names(self, model, column_names, unique=None, primary_key=None, index=None): + def _constraint_names(self, model, column_names=None, unique=None, primary_key=None, index=None): "Returns all constraint names matching the columns and conditions" - column_names = set(column_names) + column_names = set(column_names) if column_names else None constraints = self.connection.introspection.get_constraints(self.connection.cursor(), model._meta.db_table) result = [] for name, infodict in constraints.items(): - if column_names == infodict['columns']: + if column_names is None or column_names == infodict['columns']: if unique is not None and infodict['unique'] != unique: continue - if primary_key is not None and infodict['primary_key'] != unique: + if primary_key is not None and infodict['primary_key'] != primary_key: continue if index is not None and infodict['index'] != index: continue diff --git a/tests/modeltests/schema/tests.py b/tests/modeltests/schema/tests.py index 6ef24ca11e..db374dc7ad 100644 --- a/tests/modeltests/schema/tests.py +++ b/tests/modeltests/schema/tests.py @@ -478,3 +478,37 @@ class SchemaTests(TestCase): "slug", connection.introspection.get_indexes(connection.cursor(), Book._meta.db_table), ) + + def test_primary_key(self): + """ + Tests altering of the primary key + """ + # Create the table + editor = connection.schema_editor() + editor.start() + editor.create_model(Tag) + editor.commit() + # Ensure the table is there and has the right PK + self.assertTrue( + connection.introspection.get_indexes(connection.cursor(), Tag._meta.db_table)['id']['primary_key'], + ) + # Alter to change the PK + new_field = SlugField(primary_key=True) + new_field.set_attributes_from_name("slug") + editor = connection.schema_editor() + editor.start() + editor.delete_field(Tag, Tag._meta.get_field_by_name("id")[0]) + editor.alter_field( + Tag, + Tag._meta.get_field_by_name("slug")[0], + new_field, + ) + editor.commit() + # Ensure the PK changed + self.assertNotIn( + 'id', + connection.introspection.get_indexes(connection.cursor(), Tag._meta.db_table), + ) + self.assertTrue( + connection.introspection.get_indexes(connection.cursor(), Tag._meta.db_table)['slug']['primary_key'], + )