如何将Django模型父类从models.Model改为PolymorphicModel及问题解决

问题根源 #

你尝试用PolymorphicModel创建父类Buyable来统一关联Tomato和Potato，但该方案会强制子类（Tomato/Potato）将原有主键替换为buyable_ptr，导致项目中已有的外键、多对多关联全部失效。而你写的默认值函数每次生成同一个Buyable实例（id始终为1），是因为迁移时字段默认值函数只会执行一次，并非为每条记录单独生成实例。

替代方案 #

方案1：通用外键（GenericForeignKey） #

无需修改现有Tomato、Potato模型结构，利用Django内置的ContentType实现多模型关联，适合不需要强数据库约束的场景。

代码示例：

from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation

class Tomato(models.Model):
    # 保留原有字段
    # 添加反向关联（可选，方便从Tomato查询关联的ShoppingBag）
    shopping_bags = GenericRelation('ShoppingBag')

class Potato(models.Model):
    # 保留原有字段
    shopping_bags = GenericRelation('ShoppingBag')

class ShoppingBag(models.Model):
    # 关联ContentType表，记录关联的模型类型
    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    # 记录关联模型实例的ID
    object_id = models.PositiveIntegerField()
    # 通用外键，用于ORM层面的关联操作
    content_object = GenericForeignKey('content_type', 'object_id')
    
    # 其他业务字段

优缺点：

• 优势：完全兼容现有模型的关联关系，无需修改历史数据，扩展性强（后续新增可关联模型无需改动现有代码）。
• 劣势：无数据库级外键约束，需要手动保证数据一致性；多态查询的性能略低于常规外键。

方案2：双外键+唯一性约束 #

针对仅需关联Tomato和Potato的场景，直接在ShoppingBag中添加两个外键字段，通过数据库约束保证只能关联其中一个模型。

代码示例：

class ShoppingBag(models.Model):
    tomato = models.ForeignKey(Tomato, on_delete=models.CASCADE, null=True, blank=True)
    potato = models.ForeignKey(Potato, on_delete=models.CASCADE, null=True, blank=True)
    
    # 其他业务字段

    class Meta:
        constraints = [
            # 约束：必须关联至少一个商品
            models.CheckConstraint(
                check=models.Q(tomato__isnull=False) | models.Q(potato__isnull=False),
                name='shoppingbag_must_have_item'
            ),
            # 约束：不能同时关联两个商品
            models.CheckConstraint(
                check=models.Q(tomato__isnull=True) | models.Q(potato__isnull=True),
                name='shoppingbag_only_one_item'
            )
        ]

优缺点：

• 优势：数据库级约束保证数据合法性，ORM查询直观，性能最优。
• 劣势：扩展性差，后续新增可关联模型需添加新的外键字段和约束。

方案3：修复PolymorphicModel迁移（不推荐） #

若坚持使用多态模型，需手动修改迁移文件，避免替换原有模型的主键，步骤如下：

1. 创建空的Buyable模型（继承PolymorphicModel）：

from django.db import models
from polymorphic.models import PolymorphicModel

class Buyable(PolymorphicModel):
    pass

2. 生成初始迁移文件，然后修改迁移内容，添加批量创建Buyable实例的逻辑：

from django.db import migrations, models
import django.db.models.deletion
from polymorphic.models import PolymorphicModel

def create_buyable_instances(apps, schema_editor):
    Tomato = apps.get_model('your_app_name', 'Tomato')
    Potato = apps.get_model('your_app_name', 'Potato')
    Buyable = apps.get_model('your_app_name', 'Buyable')

    # 为每个Tomato创建对应的Buyable实例并关联
    for tomato in Tomato.objects.all():
        buyable = Buyable.objects.create()
        tomato.buyable_ptr = buyable
        tomato.save()
    
    # 为每个Potato创建对应的Buyable实例并关联
    for potato in Potato.objects.all():
        buyable = Buyable.objects.create()
        potato.buyable_ptr = buyable
        potato.save()

class Migration(migrations.Migration):
    dependencies = [
        # 依赖原有Tomato、Potato的迁移
    ]

    operations = [
        migrations.CreateModel(
            name='Buyable',
            fields=[
                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
            ],
            options={
                'abstract': False,
            },
            bases=(PolymorphicModel,),
        ),
        # 先添加buyable_ptr字段，允许为空
        migrations.AddField(
            model_name='tomato',
            name='buyable_ptr',
            field=models.OneToOneField(null=True, on_delete=django.db.models.deletion.CASCADE, parent_link=True, to='your_app_name.buyable'),
        ),
        migrations.AddField(
            model_name='potato',
            name='buyable_ptr',
            field=models.OneToOneField(null=True, on_delete=django.db.models.deletion.CASCADE, parent_link=True, to='your_app_name.buyable'),
        ),
        # 批量创建Buyable实例并关联
        migrations.RunPython(create_buyable_instances),
        # 将buyable_ptr字段设为非空
        migrations.AlterField(
            model_name='tomato',
            name='buyable_ptr',
            field=models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, parent_link=True, to='your_app_name.buyable'),
        ),
        migrations.AlterField(
            model_name='potato',
            name='buyable_ptr',
            field=models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, parent_link=True, to='your_app_name.buyable'),
        ),
        # 修改Tomato、Potato的继承关系（需确保模型文件中已改为继承Buyable）
        migrations.AlterModelBases(
            name='tomato',
            bases=('your_app_name.buyable',),
        ),
        migrations.AlterModelBases(
            name='potato',
            bases=('your_app_name.buyable',),
        ),
    ]

3. 修改Tomato和Potato模型，使其继承Buyable：

class Tomato(Buyable):
    # 原有字段
    pass

class Potato(Buyable):
    # 原有字段
    pass

优缺点：

• 优势：支持标准的多态查询，扩展性好。
• 劣势：迁移步骤复杂，手动修改迁移文件风险高，若操作失误可能导致数据丢失；原有模型的主键逻辑被修改，需全面测试现有关联。

总结 #

优先推荐通用外键（GenericForeignKey）或双外键约束方案，无需改动现有模型结构，风险低且适配性强。若需强多态支持，再考虑修复PolymorphicModel的迁移流程。

内容的提问来源于stack exchange，提问作者Riki