diff --git a/django/db/backends/creation.py b/django/db/backends/creation.py
index ef594b7bfc..9b11a63341 100644
--- a/django/db/backends/creation.py
+++ b/django/db/backends/creation.py
@@ -132,115 +132,6 @@ class BaseDatabaseCreation(object):
             del pending_references[model]
         return final_output
 
-    def sql_for_many_to_many(self, model, style):
-        "Return the CREATE TABLE statments for all the many-to-many tables defined on a model"
-        import warnings
-        warnings.warn(
-            'Database creation API for m2m tables has been deprecated. M2M models are now automatically generated',
-            DeprecationWarning
-        )
-
-        output = []
-        for f in model._meta.local_many_to_many:
-            if model._meta.managed or f.rel.to._meta.managed:
-                output.extend(self.sql_for_many_to_many_field(model, f, style))
-        return output
-
-    def sql_for_many_to_many_field(self, model, f, style):
-        "Return the CREATE TABLE statements for a single m2m field"
-        import warnings
-        warnings.warn(
-            'Database creation API for m2m tables has been deprecated. M2M models are now automatically generated',
-            DeprecationWarning
-        )
-
-        from django.db import models
-        from django.db.backends.util import truncate_name
-
-        output = []
-        if f.auto_created:
-            opts = model._meta
-            qn = self.connection.ops.quote_name
-            tablespace = f.db_tablespace or opts.db_tablespace
-            if tablespace:
-                sql = self.connection.ops.tablespace_sql(tablespace, inline=True)
-                if sql:
-                    tablespace_sql = ' ' + sql
-                else:
-                    tablespace_sql = ''
-            else:
-                tablespace_sql = ''
-            table_output = [style.SQL_KEYWORD('CREATE TABLE') + ' ' + \
-                style.SQL_TABLE(qn(f.m2m_db_table())) + ' (']
-            table_output.append('    %s %s %s%s,' %
-                (style.SQL_FIELD(qn('id')),
-                style.SQL_COLTYPE(models.AutoField(primary_key=True).db_type(connection=self.connection)),
-                style.SQL_KEYWORD('NOT NULL PRIMARY KEY'),
-                tablespace_sql))
-
-            deferred = []
-            inline_output, deferred = self.sql_for_inline_many_to_many_references(model, f, style)
-            table_output.extend(inline_output)
-
-            table_output.append('    %s (%s, %s)%s' %
-                (style.SQL_KEYWORD('UNIQUE'),
-                style.SQL_FIELD(qn(f.m2m_column_name())),
-                style.SQL_FIELD(qn(f.m2m_reverse_name())),
-                tablespace_sql))
-            table_output.append(')')
-            if opts.db_tablespace:
-                # f.db_tablespace is only for indices, so ignore its value here.
-                table_output.append(self.connection.ops.tablespace_sql(opts.db_tablespace))
-            table_output.append(';')
-            output.append('\n'.join(table_output))
-
-            for r_table, r_col, table, col in deferred:
-                r_name = '%s_refs_%s_%s' % (r_col, col, self._digest(r_table, table))
-                output.append(style.SQL_KEYWORD('ALTER TABLE') + ' %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s)%s;' %
-                (qn(r_table),
-                qn(truncate_name(r_name, self.connection.ops.max_name_length())),
-                qn(r_col), qn(table), qn(col),
-                self.connection.ops.deferrable_sql()))
-
-            # Add any extra SQL needed to support auto-incrementing PKs
-            autoinc_sql = self.connection.ops.autoinc_sql(f.m2m_db_table(), 'id')
-            if autoinc_sql:
-                for stmt in autoinc_sql:
-                    output.append(stmt)
-        return output
-
-    def sql_for_inline_many_to_many_references(self, model, field, style):
-        "Create the references to other tables required by a many-to-many table"
-        import warnings
-        warnings.warn(
-            'Database creation API for m2m tables has been deprecated. M2M models are now automatically generated',
-            DeprecationWarning
-        )
-
-        from django.db import models
-        opts = model._meta
-        qn = self.connection.ops.quote_name
-
-        table_output = [
-            '    %s %s %s %s (%s)%s,' %
-                (style.SQL_FIELD(qn(field.m2m_column_name())),
-                style.SQL_COLTYPE(models.ForeignKey(model).db_type(connection=self.connection)),
-                style.SQL_KEYWORD('NOT NULL REFERENCES'),
-                style.SQL_TABLE(qn(opts.db_table)),
-                style.SQL_FIELD(qn(opts.pk.column)),
-                self.connection.ops.deferrable_sql()),
-            '    %s %s %s %s (%s)%s,' %
-                (style.SQL_FIELD(qn(field.m2m_reverse_name())),
-                style.SQL_COLTYPE(models.ForeignKey(field.rel.to).db_type(connection=self.connection)),
-                style.SQL_KEYWORD('NOT NULL REFERENCES'),
-                style.SQL_TABLE(qn(field.rel.to._meta.db_table)),
-                style.SQL_FIELD(qn(field.rel.to._meta.pk.column)),
-                self.connection.ops.deferrable_sql())
-        ]
-        deferred = []
-
-        return table_output, deferred
-
     def sql_indexes_for_model(self, model, style):
         "Returns the CREATE INDEX SQL statements for a single model"
         if not model._meta.managed or model._meta.proxy:
@@ -314,24 +205,6 @@ class BaseDatabaseCreation(object):
         del references_to_delete[model]
         return output
 
-    def sql_destroy_many_to_many(self, model, f, style):
-        "Returns the DROP TABLE statements for a single m2m field"
-        import warnings
-        warnings.warn(
-            'Database creation API for m2m tables has been deprecated. M2M models are now automatically generated',
-            DeprecationWarning
-        )
-
-        qn = self.connection.ops.quote_name
-        output = []
-        if f.auto_created:
-            output.append("%s %s;" % (style.SQL_KEYWORD('DROP TABLE'),
-                style.SQL_TABLE(qn(f.m2m_db_table()))))
-            ds = self.connection.ops.drop_sequence_sql("%s_%s" % (model._meta.db_table, f.column))
-            if ds:
-                output.append(ds)
-        return output
-
     def create_test_db(self, verbosity=1, autoclobber=False):
         """
         Creates a test database, prompting the user for confirmation if the