Removed deprecated DB backend functions for creating m2m tables. (f9972bcf) · Commits · Dom Sekotill / django

django/db/backends/creation.py

+0 −127

Original line number	Diff line number	Diff line
		@@ -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