Merge pull request #2634 from loic/ticket22424 (4e32e473) · Commits · Dom Sekotill / django

django/db/backends/mysql/schema.py

+26 −1

Original line number	Diff line number	Diff line
		from django.db.backends.schema import BaseDatabaseSchemaEditor
		from django.db.models import NOT_PROVIDED
		from django.utils import six


		class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
		@@ -28,4 +30,27 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
		def quote_value(self, value):
		# Inner import to allow module to fail to load gracefully
		import MySQLdb.converters

		if isinstance(value, six.string_types):
		return '"%s"' % six.text_type(value)
		else:
		return MySQLdb.escape(value, MySQLdb.converters.conversions)

		def skip_default(self, field):
		"""
		MySQL doesn't accept default values for longtext and longblob
		and implicitly treats these columns as nullable.
		"""
		return field.db_type(self.connection) in {'longtext', 'longblob'}

		def add_field(self, model, field):
		super(DatabaseSchemaEditor, self).add_field(model, field)

		# Simulate the effect of a one-off default.
		if self.skip_default(field) and field.default not in {None, NOT_PROVIDED}:
		effective_default = self.effective_default(field)
		self.execute('UPDATE %(table)s SET %(column)s=%(default)s' % {
		'table': self.quote_name(model._meta.db_table),
		'column': self.quote_name(field.column),
		'default': self.quote_value(effective_default),
		})

django/db/backends/schema.py

+9 −1

Original line number	Diff line number	Diff line
		@@ -118,6 +118,7 @@ class BaseDatabaseSchemaEditor(object):
		null = field.null
		# If we were told to include a default value, do so
		default_value = self.effective_default(field)
		include_default = include_default and not self.skip_default(field)
		if include_default and default_value is not None:
		if self.connection.features.requires_literal_defaults:
		# Some databases can't take defaults as a parameter (oracle)
		@@ -148,6 +149,13 @@ class BaseDatabaseSchemaEditor(object):
		# Return the sql
		return sql, params

		def skip_default(self, field):
		"""
		Some backends don't accept default values for certain columns types
		(i.e. MySQL longtext and longblob).
		"""
		return False

		def prepare_default(self, value):
		"""
		Only used for backends which have requires_literal_defaults feature
		@@ -398,7 +406,7 @@ class BaseDatabaseSchemaEditor(object):
		self.execute(sql, params)
		# Drop the default if we need to
		# (Django usually does not use in-database defaults)
		if field.default is not None:
		if not self.skip_default(field) and field.default is not None:
		sql = self.sql_alter_column % {
		"table": self.quote_name(model._meta.db_table),
		"changes": self.sql_alter_column_no_default % {

django/db/backends/sqlite3/schema.py

+17 −3

Original line number	Diff line number	Diff line
		import codecs

		from decimal import Decimal
		from django.utils import six
		from django.apps.registry import Apps
		@@ -28,6 +30,16 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
		return '"%s"' % six.text_type(value)
		elif value is None:
		return "NULL"
		elif isinstance(value, (bytes, bytearray, six.memoryview)):
		# Bytes are only allowed for BLOB fields, encoded as string
		# literals containing hexadecimal data and preceded by a single "X"
		# character:
		# value = b'\x01\x02' => value_hex = b'0102' => return X'0102'
		value = bytes(value)
		hex_encoder = codecs.getencoder('hex_codec')
		value_hex, _length = hex_encoder(value)
		# Use 'ascii' encoding for b'01' => '01', no need to use force_text here.
		return "X'%s'" % value_hex.decode('ascii')
		else:
		raise ValueError("Cannot quote parameter value %r of type %s" % (value, type(value)))

		@@ -37,7 +49,9 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
		"""
		# Work out the new fields dict / mapping
		body = dict((f.name, f) for f in model._meta.local_fields)
		mapping = dict((f.column, f.column) for f in model._meta.local_fields)
		# Since mapping might mix column names and default values,
		# its values must be already quoted.
		mapping = dict((f.column, self.quote_name(f.column)) for f in model._meta.local_fields)
		# If any of the new or altered fields is introducing a new PK,
		# remove the old one
		restore_pk_field = None
		@@ -62,7 +76,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
		del body[old_field.name]
		del mapping[old_field.column]
		body[new_field.name] = new_field
		mapping[new_field.column] = old_field.column
		mapping[new_field.column] = self.quote_name(old_field.column)
		# Remove any deleted fields
		for field in delete_fields:
		del body[field.name]
		@@ -90,7 +104,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
		self.execute("INSERT INTO %s (%s) SELECT %s FROM %s" % (
		self.quote_name(temp_model._meta.db_table),
		', '.join(self.quote_name(x) for x, y in field_maps),
		', '.join(self.quote_name(y) for x, y in field_maps),
		', '.join(y for x, y in field_maps),
		self.quote_name(model._meta.db_table),
		))
		# Delete the old table (not using self.delete_model to avoid deleting

tests/migrations/test_operations.py

+132 −0

Original line number	Diff line number	Diff line
		from __future__ import unicode_literals

		import unittest

		try:
		@@ -312,6 +314,136 @@ class OperationTests(MigrationTestBase):
		operation.database_backwards("test_adfl", editor, new_state, project_state)
		self.assertColumnNotExists("test_adfl_pony", "height")

		def test_add_charfield(self):
		"""
		Tests the AddField operation on TextField.
		"""
		project_state = self.set_up_test_model("test_adchfl")

		new_apps = project_state.render()
		Pony = new_apps.get_model("test_adchfl", "Pony")
		pony = Pony.objects.create(weight=42)

		new_state = self.apply_operations("test_adchfl", project_state, [
		migrations.AddField(
		"Pony",
		"text",
		models.CharField(max_length=10, default="some text"),
		),
		migrations.AddField(
		"Pony",
		"empty",
		models.CharField(max_length=10, default=""),
		),
		# If not properly quoted digits would be interpreted as an int.
		migrations.AddField(
		"Pony",
		"digits",
		models.CharField(max_length=10, default="42"),
		),
		# Manual quoting is fragile and could trip on quotes. Refs #xyz.
		migrations.AddField(
		"Pony",
		"quotes",
		models.CharField(max_length=10, default='"\'"'),
		),
		])

		new_apps = new_state.render()
		Pony = new_apps.get_model("test_adchfl", "Pony")
		pony = Pony.objects.get(pk=pony.pk)
		self.assertEqual(pony.text, "some text")
		self.assertEqual(pony.empty, "")
		self.assertEqual(pony.digits, "42")
		self.assertEqual(pony.quotes, '"\'"')

		def test_add_textfield(self):
		"""
		Tests the AddField operation on TextField.
		"""
		project_state = self.set_up_test_model("test_adtxtfl")

		new_apps = project_state.render()
		Pony = new_apps.get_model("test_adtxtfl", "Pony")
		pony = Pony.objects.create(weight=42)

		new_state = self.apply_operations("test_adtxtfl", project_state, [
		migrations.AddField(
		"Pony",
		"text",
		models.TextField(default="some text"),
		),
		migrations.AddField(
		"Pony",
		"empty",
		models.TextField(default=""),
		),
		# If not properly quoted digits would be interpreted as an int.
		migrations.AddField(
		"Pony",
		"digits",
		models.TextField(default="42"),
		),
		# Manual quoting is fragile and could trip on quotes. Refs #xyz.
		migrations.AddField(
		"Pony",
		"quotes",
		models.TextField(default='"\'"'),
		),
		])

		new_apps = new_state.render()
		Pony = new_apps.get_model("test_adtxtfl", "Pony")
		pony = Pony.objects.get(pk=pony.pk)
		self.assertEqual(pony.text, "some text")
		self.assertEqual(pony.empty, "")
		self.assertEqual(pony.digits, "42")
		self.assertEqual(pony.quotes, '"\'"')

		def test_add_binaryfield(self):
		"""
		Tests the AddField operation on TextField/BinaryField.
		"""
		project_state = self.set_up_test_model("test_adbinfl")

		new_apps = project_state.render()
		Pony = new_apps.get_model("test_adbinfl", "Pony")
		pony = Pony.objects.create(weight=42)

		new_state = self.apply_operations("test_adbinfl", project_state, [
		migrations.AddField(
		"Pony",
		"blob",
		models.BinaryField(default=b"some text"),
		),
		migrations.AddField(
		"Pony",
		"empty",
		models.BinaryField(default=b""),
		),
		# If not properly quoted digits would be interpreted as an int.
		migrations.AddField(
		"Pony",
		"digits",
		models.BinaryField(default=b"42"),
		),
		# Manual quoting is fragile and could trip on quotes. Refs #xyz.
		migrations.AddField(
		"Pony",
		"quotes",
		models.BinaryField(default=b'"\'"'),
		),
		])

		new_apps = new_state.render()
		Pony = new_apps.get_model("test_adbinfl", "Pony")
		pony = Pony.objects.get(pk=pony.pk)
		# SQLite returns buffer/memoryview, cast to bytes for checking.
		self.assertEqual(bytes(pony.blob), b"some text")
		self.assertEqual(bytes(pony.empty), b"")
		self.assertEqual(bytes(pony.digits), b"42")
		self.assertEqual(bytes(pony.quotes), b'"\'"')

		def test_column_name_quoting(self):
		"""
		Column names that are SQL keywords shouldn't cause problems when used