From f9972bcf8675d26291f09c7acbc9da2f5f1a2327 Mon Sep 17 00:00:00 2001 From: Russell Keith-Magee Date: Sat, 2 Apr 2011 08:38:25 +0000 Subject: [PATCH] Removed deprecated DB backend functions for creating m2m tables. git-svn-id: http://code.djangoproject.com/svn/django/trunk@15979 bcc190cf-cafb-0310-a4f2-bffc1f526a37 --- django/db/backends/creation.py | 127 --------------------------------- 1 file changed, 127 deletions(-) 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