datos - ¿Cómo agregar un nuevo campo a un modelo con nuevas migraciones de Django?

django+base de datos

Question

Estoy utilizando el método contribute_to_class clase pero no sé cómo crear el campo en la base de datos con nuevas migraciones.

Answer 1

Para poder hacer eso y tener el archivo de migración ubicado en la aplicación donde realmente agrego el campo en lugar de tener la migración ubicada dentro de la aplicación a la que pertenece el modelo, tuve que escribir mi propia clase base de Migración.

Si utiliza contribute_to_class dentro de la misma aplicación que el modelo original, la respuesta de @nima funciona a la perfección, aunque no veo el punto de utilizar contrib_contro_clase.

Aquí está el código. Es el código original de Django adaptado para migrar un modelo de self.migrated_app lugar de self.app_label :

from django.db import migrations


class Migration(migrations.Migration):

  migrated_app = None

  def __init__(self, name, app_label):
    super(Migration,self).__init__(name, app_label)
    if self.migrated_app is None:
      self.migrated_app = self.app_label

  def mutate_state(self, project_state):
    new_state = project_state.clone()
    for operation in self.operations:
        operation.state_forwards(self.migrated_app, new_state)
    return new_state

  def apply(self, project_state, schema_editor, collect_sql=False):
    for operation in self.operations:
      if collect_sql and not operation.reduces_to_sql:
        schema_editor.collected_sql.append("--")
        schema_editor.collected_sql.append("-- MIGRATION NOW PERFORMS OPERATION THAT CANNOT BE WRITTEN AS SQL:")
        schema_editor.collected_sql.append("-- %s" % operation.describe())
        schema_editor.collected_sql.append("--")
        continue
      new_state = project_state.clone()
      operation.state_forwards(self.migrated_app, new_state)
      if not schema_editor.connection.features.can_rollback_ddl and operation.atomic:
        with atomic(schema_editor.connection.alias):
          operation.database_forwards(self.migrated_app, schema_editor, project_state, new_state)
      else:
        operation.database_forwards(self.migrated_app, schema_editor, project_state, new_state)
      project_state = new_state
    return project_state

  def unapply(self, project_state, schema_editor, collect_sql=False):
    to_run = []
    for operation in self.operations:
      if collect_sql and not operation.reduces_to_sql:
        schema_editor.collected_sql.append("--")
        schema_editor.collected_sql.append("-- MIGRATION NOW PERFORMS OPERATION THAT CANNOT BE WRITTEN AS SQL:")
        schema_editor.collected_sql.append("-- %s" % operation.describe())
        schema_editor.collected_sql.append("--")
        continue
      if not operation.reversible:
        raise Migration.IrreversibleError("Operation %s in %s is not reversible" % (operation, self))
      new_state = project_state.clone()
      operation.state_forwards(self.migrated_app, new_state)
      to_run.append((operation, project_state, new_state))
      project_state = new_state
    to_run.reverse()
    for operation, to_state, from_state in to_run:
      if not schema_editor.connection.features.can_rollback_ddl and operation.atomic:
        with atomic(schema_editor.connection.alias):
          operation.database_backwards(self.migrated_app, schema_editor, from_state, to_state)
      else:
        operation.database_backwards(self.migrated_app, schema_editor, from_state, to_state)
    return project_state

Con esta nueva clase de Migración ubicada en base.utils una migración escrita a mano se vería así. También puede dejar que Django escriba la migración por usted dentro de la aplicación "incorrecta", mueva el archivo y actualícelo para usar la clase de migración personalizada:

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.db import models, migrations
from base.utils import Migration
import dynamicsites.fields


class Migration(Migration):

    dependencies = [
        (''sites'', ''0001_initial''),
        (''base'', ''0001_initial''),
    ]

    migrated_app = ''sites''

    operations = [
        migrations.AddField(
            model_name=''site'',
            name=''folder_name'',
            field=dynamicsites.fields.FolderNameField(default='''', help_text=b"Folder name for this site''s files.  The name may only consist of lowercase characters, numbers (0-9), and/or underscores", max_length=64, blank=True),
            preserve_default=False,
        ),
        migrations.AddField(
            model_name=''site'',
            name=''subdomains'',
            field=dynamicsites.fields.SubdomainListField(default=(), help_text=b''Comma separated list of subdomains this site supports.  Leave blank to support all subdomains'', blank=True),
            preserve_default=False,
        ),
    ]

Clase de migración personalizada para Django 1.8

from django.db import migrations


class Migration(migrations.Migration):

  migrated_app = None

  def __init__(self, name, app_label):
    super(Migration,self).__init__(name, app_label)
    if self.migrated_app is None:
      self.migrated_app = self.app_label

  def __eq__(self, other):
    if not isinstance(other, Migration):
      if not isinstance(other, migrations.Migration):
        return False
      return (self.name == other.name) and (self.migrated_app == other.app_label)
    return (self.name == other.name) and (self.migrated_app == other.migrated_app)

  def __hash__(self):
    return hash("%s.%s" % (self.app_label, self.name))

  def mutate_state(self, project_state, preserve=True):
    new_state = project_state
    if preserve:
      new_state = project_state.clone()

    for operation in self.operations:
      operation.state_forwards(self.migrated_app, new_state)
    return new_state

  def apply(self, project_state, schema_editor, collect_sql=False):
    for operation in self.operations:
      if collect_sql and not operation.reduces_to_sql:
        schema_editor.collected_sql.append("--")
        schema_editor.collected_sql.append("-- MIGRATION NOW PERFORMS OPERATION THAT CANNOT BE "
                                           "WRITTEN AS SQL:")
        schema_editor.collected_sql.append("-- %s" % operation.describe())
        schema_editor.collected_sql.append("--")
        continue
      old_state = project_state.clone()
      operation.state_forwards(self.migrated_app, project_state)
      if not schema_editor.connection.features.can_rollback_ddl and operation.atomic:
        with atomic(schema_editor.connection.alias):
          operation.database_forwards(self.migrated_app, schema_editor, old_state, project_state)
      else:
        operation.database_forwards(self.migrated_app, schema_editor, old_state, project_state)
    return project_state

  def unapply(self, project_state, schema_editor, collect_sql=False):
    to_run = []
    new_state = project_state
    for operation in self.operations:
      if not operation.reversible:
        raise Migration.IrreversibleError("Operation %s in %s is not reversible" % (operation, self))
      new_state = new_state.clone()
      old_state = new_state.clone()
      operation.state_forwards(self.migrated_app, new_state)
      to_run.insert(0, (operation, old_state, new_state))

    for operation, to_state, from_state in to_run:
      if collect_sql:
        if not operation.reduces_to_sql:
          schema_editor.collected_sql.append("--")
          schema_editor.collected_sql.append("-- MIGRATION NOW PERFORMS OPERATION THAT CANNOT BE "
                                             "WRITTEN AS SQL:")
          schema_editor.collected_sql.append("-- %s" % operation.describe())
          schema_editor.collected_sql.append("--")
          continue
      if not schema_editor.connection.features.can_rollback_ddl and operation.atomic:
        with atomic(schema_editor.connection.alias):
          operation.database_backwards(self.migrated_app, schema_editor, from_state, to_state)
      else:
        operation.database_backwards(self.migrated_app, schema_editor, from_state, to_state)
      return project_state

Answer 2

Para responder a su pregunta, con la nueva migración introducida en Django 1.7 , para agregar un nuevo campo a un modelo, simplemente puede agregar ese campo a su modelo e iniciar migraciones con ./manage.py makemigrations y luego ejecutar ./manage.py migrate y el nuevo campo se agregará a tu base de datos.

Sin embargo, para evitar lidiar con los errores de sus modelos existentes, puede usar --fake :

1. Inicialice las migraciones para sus modelos existentes:

   ./manage.py makemigrations myapp

2. Migraciones falsas para modelos existentes:

   ./manage.py migrate --fake myapp

3. Agregue el nuevo campo a myapp.models:

   from django.db import models
   
   class MyModel(models.Model):
       ... #existing fields
       newfield = models.CharField(max_length=100) #new field

4. Ejecute makemigrations de nuevo (esto agregará un nuevo archivo de migración en la carpeta de migraciones que agregará el campo nuevo a db):

   ./manage.py makemigrations myapp

5. Ejecutar migrar de nuevo:

   ./manage.py migrate myapp

Answer 3

Puedes crear así:

from django.db.models import CharField
from django.db.models.signals import class_prepared

def add_field(sender, **kwargs):
    """
    class_prepared signal handler that checks for the model named
    MyModel as the sender, and adds a CharField
    to it.
    """
    if sender.__name__ == "MyModel":
        field = CharField("New field", max_length=100)
        field.contribute_to_class(sender, "new_field")

class_prepared.connect(add_field)

Consulte " Inyección de campo del modelo Django " para obtener más información.