Comment ajouter un nouveau champ à un modèle avec de nouvelles migrations Django?

Question

J'utilise le contribute_to_class mais je ne sais pas comment créer le champ dans la base de données avec de nouvelles migrations.

Answer 1

Pour répondre à votre question, avec la nouvelle migration introduite dans Django 1.7, afin d'ajouter un nouveau champ à un modèle, vous pouvez simplement ajouter ce champ à votre modèle et initialiser les migrations avec ./manage.py makemigrations puis exécutez ./manage.py migrate et le nouveau champ sera ajouté à votre base de données.

Cependant, pour éviter de traiter les erreurs de vos modèles existants, vous pouvez utiliser le --fake:

1. Initialisez les migrations pour vos modèles existants:

   ./manage.py makemigrations myapp
   

2. Fausses migrations pour les modèles existants:

   ./manage.py migrate --fake myapp
   

3. Ajoutez le nouveau champ à myapp.models:

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

4. Exécutez à nouveau makemigrations (cela ajoutera un nouveau fichier de migration dans le dossier des migrations qui ajoutera le nouveau champ à db):

   ./manage.py makemigrations myapp
   

5. Exécutez à nouveau la migration:

   ./manage.py migrate myapp
   

Answer 2

Pour pouvoir faire cela et avoir le fichier de migration situé dans l'application où j'ajoute réellement le champ au lieu d'avoir la migration située dans l'application à laquelle appartient le modèle, j'ai dû écrire ma propre classe de base de migration.

Si tu utilises contribute_to_class dans la même application que le modèle d'origine, la réponse de @ nima fonctionne parfaitement, même si je ne vois pas l'intérêt d'utiliser contribute_to_class puis.

Voici le code. C'est le code original de Django adapté pour migrer un modèle de self.migrated_app au lieu 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

Avec cette nouvelle classe de migration située dans base.utils une migration manuscrite ressemblerait à ceci. Vous pouvez également laisser Django écrire la migration pour vous dans la "mauvaise" application, déplacer le fichier et le mettre à jour pour utiliser la classe de migration personnalisée:

# -*- 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,
        ),
    ]

---

Classe de migration personnalisée pour 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 3

Vous pouvez créer comme ceci:

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)

Voir " Django Model Field Injection " pour plus d'informations.