复杂场景下如何规避Django缺乏复合键的限制？

你说得没错，Django目前确实不支持复合外键，这对于你这种需要关联多表复合主键的场景来说，常规代理键方案根本没法满足数据完整性要求。下面是几种可行的变通思路，你可以根据需求选择：

1. 数据库触发器（最可靠的底层保障） #

这是你提到的方案，也是保证数据完整性最稳妥的方式——毕竟触发器是在数据库层面生效，不管数据是通过Django ORM、直接SQL还是其他工具插入，都会被拦截。

针对你的ABC表，你可以创建两个BEFORE INSERT触发器，分别验证(id_a, id_b)存在于AB表、(id_b, id_c)存在于BC表：

-- 验证(id_a, id_b)在AB表中存在
CREATE TRIGGER validate_ab_abc BEFORE INSERT ON ABC
FOR EACH ROW
BEGIN
    SELECT RAISE(ABORT, "Invalid (id_a, id_b) pair")
    WHERE NOT EXISTS (SELECT 1 FROM AB WHERE AB.id_a = NEW.id_a AND AB.id_b = NEW.id_b);
END;

-- 验证(id_b, id_c)在BC表中存在
CREATE TRIGGER validate_bc_abc BEFORE INSERT ON ABC
FOR EACH ROW
BEGIN
    SELECT RAISE(ABORT, "Invalid (id_b, id_c) pair")
    WHERE NOT EXISTS (SELECT 1 FROM BC WHERE BC.id_b = NEW.id_b AND BC.id_c = NEW.id_c);
END;

你可以在Django的迁移文件中通过RunSQL来执行这些触发器创建语句，比如新建一个空迁移：

from django.db import migrations

class Migration(migrations.Migration):
    dependencies = [
        ('your_app_name', 'previous_migration_name'),
    ]

    operations = [
        migrations.RunSQL("""
            CREATE TRIGGER validate_ab_abc BEFORE INSERT ON ABC
            FOR EACH ROW
            BEGIN
                SELECT RAISE(ABORT, "Invalid (id_a, id_b) pair")
                WHERE NOT EXISTS (SELECT 1 FROM AB WHERE AB.id_a = NEW.id_a AND AB.id_b = NEW.id_b);
            END;
        """),
        migrations.RunSQL("""
            CREATE TRIGGER validate_bc_abc BEFORE INSERT ON ABC
            FOR EACH ROW
            BEGIN
                SELECT RAISE(ABORT, "Invalid (id_b, id_c) pair")
                WHERE NOT EXISTS (SELECT 1 FROM BC WHERE BC.id_b = NEW.id_b AND BC.id_c = NEW.id_c);
            END;
        """),
    ]

2. Django模型层验证（应用层前置拦截） #

数据库约束是核心，但你也可以在Django模型里添加验证逻辑，提前在应用层拦截非法数据，提升用户体验：

from django.db import models
from django.core.exceptions import ValidationError
from .models import AB, BC  # 导入你的AB、BC模型

class ABC(models.Model):
    id_a = models.IntegerField()
    id_b = models.IntegerField()
    id_c = models.IntegerField()
    blah = models.TextField()

    class Meta:
        constraints = [
            models.UniqueConstraint(fields=['id_a', 'id_b', 'id_c'], name='unique_abc_tuple'),
        ]

    def clean(self):
        super().clean()
        # 验证(id_a, id_b)组合合法性
        if not AB.objects.filter(id_a=self.id_a, id_b=self.id_b).exists():
            raise ValidationError("该(id_a, id_b)组合在AB表中不存在")
        # 验证(id_b, id_c)组合合法性
        if not BC.objects.filter(id_b=self.id_b, id_c=self.id_c).exists():
            raise ValidationError("该(id_b, id_c)组合在BC表中不存在")

    def save(self, *args, **kwargs):
        self.clean()
        super().save(*args, **kwargs)

⚠️ 注意：这种方法只能拦截通过Django ORM插入的数据，如果直接操作数据库（比如手动执行SQL），这个验证就会失效，所以必须配合数据库层面的约束使用。

3. 手动添加数据库复合外键（直接强化约束） #

虽然Django不支持，但你可以直接在数据库中给ABC表添加复合外键约束（SQLite是支持的）：

ALTER TABLE ABC ADD CONSTRAINT fk_abc_ab FOREIGN KEY (id_a, id_b) REFERENCES AB(id_a, id_b);
ALTER TABLE ABC ADD CONSTRAINT fk_abc_bc FOREIGN KEY (id_b, id_c) REFERENCES BC(id_b, id_c);

同样，你可以通过Django的RunSQL迁移来执行这些语句。不过要注意：Django的ORM不会识别这些外键，所以在反向生成模型、某些ORM关联操作时可能会有兼容性问题，但数据完整性是完全能保证的。

总结 #

• 如果要绝对保证数据完整性，优先选择数据库触发器+复合外键的组合，覆盖所有数据插入场景；
• Django模型层验证是辅助手段，用来在应用层提前报错，优化用户体验，但不能替代数据库约束；
• 目前Django确实没有原生支持复合外键的方案，这些变通方法是现阶段的最优解。

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