使用 South 重构带有继承的 Django 模型

Question

我想知道 Django south 是否可以进行以下迁移并仍然保留数据。

之前：

我目前有两个应用程序，一个称为电视，一个称为电影，每个应用程序都有一个 VideoFile 模型（此处简化）：

tv/models.py:

class VideoFile(models.Model):
    show = models.ForeignKey(Show, blank=True, null=True)
    name = models.CharField(max_length=1024, blank=True)
    size = models.IntegerField(blank=True, null=True)
    ctime = models.DateTimeField(blank=True, null=True)

movies/models.py:

class VideoFile(models.Model):
    movie = models.ForeignKey(Movie, blank=True, null=True)
    name = models.CharField(max_length=1024, blank=True)
    size = models.IntegerField(blank=True, null=True)
    ctime = models.DateTimeField(blank=True, null=True)

：

因为这两个视频文件对象非常相似，所以我想消除重复并在一个名为 media 的单独应用程序中创建一个新模型，该应用程序包含通用 VideoFile 类并使用继承来扩展它：

media/models。 py:

class VideoFile(models.Model):
    name = models.CharField(max_length=1024, blank=True)
    size = models.IntegerField(blank=True, null=True)
    ctime = models.DateTimeField(blank=True, null=True)

tv/models.py:

class VideoFile(media.models.VideoFile):
    show = models.ForeignKey(Show, blank=True, null=True)

movies/models.py:

class VideoFile(media.models.VideoFile):
    movie = models.ForeignKey(Movie, blank=True, null=True)

所以我的问题是，如何使用 django-south 完成此任务并仍然保持现有数据？

所有这三个应用程序都已由南部迁移管理，根据南部文档，将架构和数据迁移结合起来是不好的做法，他们建议应该通过几个步骤来完成。

我认为可以使用像这样的单独迁移来完成（假设已经创建了 media.VideoFile）

1. 架构迁移以重命名 tv.VideoFile 和 movie.VideoFile 中的所有字段，这些字段将移动到新的 media.VideoFile 模型，也许会移动到 old_name 之类的东西、old_size 等
2. 架构迁移到 tv.VideoFile 和 movie.VideoFile 以从 media.VideoFile 继承
3. 数据迁移将 old_name 复制到 name，old_size 复制到 size 等
4. 架构迁移以删除 old_ 字段

在我完成所有这些工作之前，您认为那会起作用吗？有更好的办法吗？

如果您感兴趣，该项目托管在此处：http://code.google.com/p /中值/

Answer 1

查看下面 Paul 的回复，了解有关与较新版本 Django/South 的兼容性的一些说明。

---

这似乎是一个有趣的问题，而且我正在成为 South 的忠实粉丝，因此我决定研究一下这个有点。我根据您上面描述的摘要构建了一个测试项目，并成功使用 South 来执行您所询问的迁移。在我们开始编写代码之前，请注意以下几点：

• South 文档建议分开进行架构迁移和数据迁移。我也这样做了。

• 在后端，Django 通过在继承模型上自动创建 OneToOne 字段来表示继承表

• 理解这一点，我们的 South 迁移需要手动正确处理 OneToOne 字段，但是，在对此进行实验时，South（或者可能是 Django 本身）似乎无法在具有相同名称的多个继承表上创建 OneToOne 字段。因此，我将电影/电视应用程序中的每个子表重命名为各自的应用程序（即 MovieVideoFile/ShowVideoFile）。

• 在实际的数据迁移代码中，South 似乎更喜欢先创建 OneToOne 字段，然后向其分配数据。在创建过程中将数据分配给 OneToOne 字段会导致 South 感到窒息。 （对 South 的所有酷性的公平妥协）。

说了这么多，我尝试保留发出的控制台命令的日志。必要时我会插入评论。最终代码在底部。

命令历史

django-admin.py startproject southtest
manage.py startapp movies
manage.py startapp tv
manage.py syncdb
manage.py startmigration movies --initial
manage.py startmigration tv --initial
manage.py migrate
manage.py shell          # added some fake data...
manage.py startapp media
manage.py startmigration media --initial
manage.py migrate
# edited code, wrote new models, but left old ones intact
manage.py startmigration movies unified-videofile --auto
# create a new (blank) migration to hand-write data migration
manage.py startmigration movies videofile-to-movievideofile-data 
manage.py migrate
# edited code, wrote new models, but left old ones intact
manage.py startmigration tv unified-videofile --auto
# create a new (blank) migration to hand-write data migration
manage.py startmigration tv videofile-to-movievideofile-data
manage.py migrate
# removed old VideoFile model from apps
manage.py startmigration movies removed-videofile --auto
manage.py startmigration tv removed-videofile --auto
manage.py migrate

为了节省篇幅，并且由于模型最终看起来总是相同的，我将仅使用“电影”应用程序进行演示。

movie/models.py

from django.db import models
from media.models import VideoFile as BaseVideoFile

# This model remains until the last migration, which deletes 
# it from the schema.  Note the name conflict with media.models
class VideoFile(models.Model):
    movie = models.ForeignKey(Movie, blank=True, null=True)
    name = models.CharField(max_length=1024, blank=True)
    size = models.IntegerField(blank=True, null=True)
    ctime = models.DateTimeField(blank=True, null=True)

class MovieVideoFile(BaseVideoFile):
    movie = models.ForeignKey(Movie, blank=True, null=True, related_name='shows')

movie/migrations/0002_unified-videofile.py（架构迁移）

from south.db import db
from django.db import models
from movies.models import *

class Migration:

    def forwards(self, orm):

        # Adding model 'MovieVideoFile'
        db.create_table('movies_movievideofile', (
            ('videofile_ptr', orm['movies.movievideofile:videofile_ptr']),
            ('movie', orm['movies.movievideofile:movie']),
        ))
        db.send_create_signal('movies', ['MovieVideoFile'])

    def backwards(self, orm):

        # Deleting model 'MovieVideoFile'
        db.delete_table('movies_movievideofile')

movies/migration/0003_videofile-to-movievideofile-data.py（数据迁移）

from south.db import db
from django.db import models
from movies.models import *

class Migration:

    def forwards(self, orm):
        for movie in orm['movies.videofile'].objects.all():
            new_movie = orm.MovieVideoFile.objects.create(movie = movie.movie,)
            new_movie.videofile_ptr = orm['media.VideoFile'].objects.create()

            # videofile_ptr must be created first before values can be assigned
            new_movie.videofile_ptr.name = movie.name
            new_movie.videofile_ptr.size = movie.size
            new_movie.videofile_ptr.ctime = movie.ctime
            new_movie.videofile_ptr.save()

    def backwards(self, orm):
        print 'No Backwards'

南太棒了！

好的标准免责声明：您正在处理实时数据。我在这里为您提供了工作代码，但请使用 --db-dry-run 来测试您的架构。在尝试任何操作之前务必先进行备份，并且通常要小心。

兼容性通知

我将保持原始消息不变，但 South 已将命令 manage.py startmigration 更改为 manage.py schemamigration 。

Answer 2

我确实尝试过介绍 T Stone 概述的解决方案，虽然我认为这是一个极好的入门，并解释了应该如何完成工作，但我遇到了一些问题。

我认为大多数情况下您不需要需要再为父类创建表条目，即您不再需要了

new_movie.videofile_ptr = orm['media.VideoFile'].objects.create()

。 Django 现在将自动为您执行此操作（如果您有非空字段，则上述内容对我不起作用并给我一个数据库错误）。

我认为这可能是由于 django 和 South 的变化造成的，这是一个在 ubuntu 10.10 上使用 django 1.2.3 和 South 0.7.1 对我有用的版本。这些模型有点不同，但您会明白要点：

初始设置

post1/models.py:

class Author(models.Model):
    first = models.CharField(max_length=30)
    last = models.CharField(max_length=30)

class Tag(models.Model):
    name = models.CharField(max_length=30, primary_key=True)

class Post(models.Model):
    created_on = models.DateTimeField()
    author = models.ForeignKey(Author)
    tags = models.ManyToManyField(Tag)
    title = models.CharField(max_length=128, blank=True)
    content = models.TextField(blank=True)

post2/models.py:

class Author(models.Model):
    first = models.CharField(max_length=30)
    middle = models.CharField(max_length=30)
    last = models.CharField(max_length=30)

class Tag(models.Model):
    name = models.CharField(max_length=30)

class Category(models.Model):
    name = models.CharField(max_length=30)

class Post(models.Model):
    created_on = models.DateTimeField()
    author = models.ForeignKey(Author)
    tags = models.ManyToManyField(Tag)
    title = models.CharField(max_length=128, blank=True)
    content = models.TextField(blank=True)
    extra_content = models.TextField(blank=True)
    category = models.ForeignKey(Category)

显然有很多重叠，所以我想考虑一下共同点
放入通用帖子模型中，只保留其他模型中的差异
模型类。

新设置：

genpost/models.py:

class Author(models.Model):
    first = models.CharField(max_length=30)
    middle = models.CharField(max_length=30, blank=True)
    last = models.CharField(max_length=30)

class Tag(models.Model):
    name = models.CharField(max_length=30, primary_key=True)

class Post(models.Model):
    created_on = models.DateTimeField()
    author = models.ForeignKey(Author)
    tags = models.ManyToManyField(Tag)
    title = models.CharField(max_length=128, blank=True)
    content = models.TextField(blank=True)

post1/models.py:

import genpost.models as gp

class SimplePost(gp.Post):
    class Meta:
        proxy = True

post2/models.py:

import genpost.models as gp

class Category(models.Model):
    name = models.CharField(max_length=30)

class ExtPost(gp.Post):
    extra_content = models.TextField(blank=True)
    category = models.ForeignKey(Category)

如果您想继续，您将首先需要将这些模型南移：

$./manage.py schemamigration post1 --initial
$./manage.py schemamigration post2 --initial
$./manage.py migrate

迁移数据

如何进行？首先编写新的应用程序 genpost 并进行初始操作
向南迁移：（

$./manage.py schemamigration genpost --initial

我使用 $ 来表示 shell 提示符，所以不要输入它。）

接下来创建新类 SimplePost 和 ExtPost 在 post1/models.py 中
和 post2/models.py 分别（不要删除其余的类）。
然后也为这两个创建 schemamigrations：

$./manage.py schemamigration post1 --auto
$./manage.py schemamigration post2 --auto

现在我们可以应用所有这些迁移：

$./manage.py migrate

让我们进入问题的核心，将数据从 post1 和 post2 迁移到 genpost：

$./manage.py datamigration genpost post1_and_post2_to_genpost --freeze post1 --freeze post2

然后编辑 genpost/migrations/0002_post1_and_post2_to_genpost.py：

class Migration(DataMigration):

    def forwards(self, orm):

        # 
        # Migrate common data into the new genpost models
        #
        for auth1 in orm['post1.author'].objects.all():
            new_auth = orm.Author()
            new_auth.first = auth1.first
            new_auth.last = auth1.last
            new_auth.save()

        for auth2 in orm['post2.author'].objects.all():
            new_auth = orm.Author()
            new_auth.first = auth2.first
            new_auth.middle = auth2.middle
            new_auth.last = auth2.last
            new_auth.save()

        for tag in orm['post1.tag'].objects.all():
            new_tag = orm.Tag()
            new_tag.name = tag.name
            new_tag.save()

        for tag in orm['post2.tag'].objects.all():
            new_tag = orm.Tag()
            new_tag.name = tag.name
            new_tag.save()

        for post1 in orm['post1.post'].objects.all():
            new_genpost = orm.Post()

            # Content
            new_genpost.created_on = post1.created_on
            new_genpost.title = post1.title
            new_genpost.content = post1.content

            # Foreign keys
            new_genpost.author = orm['genpost.author'].objects.filter(\
                    first=post1.author.first,last=post1.author.last)[0]

            new_genpost.save() # Needed for M2M updates
            for tag in post1.tags.all():
                new_genpost.tags.add(\
                        orm['genpost.tag'].objects.get(name=tag.name))

            new_genpost.save()
            post1.delete()

        for post2 in orm['post2.post'].objects.all():
            new_extpost = p2.ExtPost() 
            new_extpost.created_on = post2.created_on
            new_extpost.title = post2.title
            new_extpost.content = post2.content

            # Foreign keys
            new_extpost.author_id = orm['genpost.author'].objects.filter(\
                    first=post2.author.first,\
                    middle=post2.author.middle,\
                    last=post2.author.last)[0].id

            new_extpost.extra_content = post2.extra_content
            new_extpost.category_id = post2.category_id

            # M2M fields
            new_extpost.save()
            for tag in post2.tags.all():
                new_extpost.tags.add(tag.name) # name is primary key

            new_extpost.save()
            post2.delete()

        # Get rid of author and tags in post1 and post2
        orm['post1.author'].objects.all().delete()
        orm['post1.tag'].objects.all().delete()
        orm['post2.author'].objects.all().delete()
        orm['post2.tag'].objects.all().delete()


    def backwards(self, orm):
        raise RuntimeError("No backwards.")

现在应用这些迁移：

$./manage.py migrate

接下来，您可以从 post1/models.py 和 post2/models.py 中删除现在多余的部分，然后创建 schemamigrations 将表更新到新状态：

$./manage.py schemamigration post1 --auto
$./manage.py schemamigration post2 --auto
$./manage.py migrate

应该就是这样！希望一切顺利，并且您已经重构了您的模型。

Answer 3

抽象模型

class VideoFile(models.Model):
    name = models.CharField(max_length=1024, blank=True)
    size = models.IntegerField(blank=True, null=True)
    ctime = models.DateTimeField(blank=True, null=True)
    class Meta:
        abstract = True

可能是通用关系对您也很有用。

Answer 4

我进行了类似的迁移，并且选择分多个步骤进行。除了创建多个迁移之外，我还创建了向后迁移，以便在出现问题时提供后备。然后，我抓取了一些测试数据并将其向前和向后迁移，直到我确信向前迁移时它能够正确输出。最后我迁移了生产站点。