抽象基类的 Django 模型字段

Question

我已经在堆栈溢出周围搜索了这个（可能很简单）问题的答案，但我看到的大多数解决方案似乎过于复杂且难以理解。

我有一个模型“Post”，它是一个抽象基类。模型“Announcement”和“Event”继承自Post。

现在我在其他模型中保留相关的事件和公告列表。例如，我在另一个模型中有“removed_events”和“removed_announcements”字段。

但是，在我的项目中，“removed_events”和“removed_announcements”的处理方式完全相同。无需区分“已删除的事件”和“已删除的公告”之间的歧义。换句话说，一个跟踪“removed_posts”的字段就足够了。

我不知道如何（或者可能不能）创建一个字段“removed_posts”，因为 Post 是抽象的。然而，现在我觉得我在代码中重复了自己（并且必须进行大量混乱的检查，以确定我正在查看的帖子是事件还是公告，并将其添加到适当的位置）删除字段）。

这里最好的选择是什么？我可以使 Posts 成为非抽象的，但 Post 对象本身不应该被创建，而且我不认为我可以在非抽象对象上强制执行此操作。

我对数据库的理解很薄弱，但我的印象是，使 Post 非抽象会使数据库由于连接而变得复杂。这有什么大不了的吗？

最后，其他模型中还有其他字段，我想将相当于 event_list 和announcement_list 的内容压缩到 post_list 中，但这些字段确实需要消除歧义。我可以根据帖子类型过滤 post_list，但是调用 filter() 会比直接单独访问事件和公告列表慢，不是吗？这里有什么建议吗？

非常感谢您阅读本文。

Answer 1

Django 中有两种模型子类化 - 抽象基类；和多表继承。

抽象基类本身不会被使用，并且没有数据库表或任何形式的标识。它们只是一种缩短代码的方法，通过对代码中的公共字段集进行分组，而不是在数据库中。

例如：

class Address(models.Model):
    street = ...
    city = ...

    class Meta:
        abstract = True


class Employee(Address):
    name = ...

class Employer(Address):
    employees = ...
    company_name = ...

这是一个人为的示例，但正如您所看到的，Employee 不是 Address，也不是 Employer。它们都只包含与地址相关的字段。本例中只有两个表； Employee 和 Employer - 它们都包含地址的所有字段。雇主地址无法与数据库级别的雇员地址进行比较 - 地址没有自己的密钥。

现在，通过多表继承（从Address中删除abstract=True），Address确实拥有一个完全属于自己的表。这将产生 3 个不同的表； 地址、雇主和雇员。雇主和雇员都将有一个返回地址的唯一外键 (OneToOneField)。

您现在可以引用地址，而不必担心它是什么类型的地址。

for address in Address.objects.all():
    try:
        print address.employer
    except Employer.DoesNotExist: # must have been an employee
        print address.employee

每个地址都有自己的主键，这意味着它可以单独保存在第四个表中：

class FakeAddresses(models.Model):
    address = models.ForeignKey(Address)
    note = ...

如果您需要使用 Post 不用担心帖子是什么类型。如果从子类访问任何 Post 字段，则会产生连接开销；但开销将是最小的。这是一个独特的索引连接，速度应该非常快。

只需确保，如果您需要访问 Post，请在查询集上使用 select_lated。

Events.objects.select_related(depth=1)

这将避免额外的查询来获取父数据，但会导致连接发生。因此，仅当您需要帖子时才使用选择相关。

最后两个注释；如果帖子既可以是公告又可以是事件，那么您需要执行传统的操作，并通过外键链接到帖子。在这种情况下，子类化将不起作用。

最后一件事是，如果父级和子级之间的连接对性能至关重要，则应该使用抽象继承；并使用通用关系来引用对性能不太重要的表中的抽象帖子。

泛型关系本质上存储这样的数据：

class GenericRelation(models.Model):
    model = ...
    model_key = ...


DeletedPosts(models.Model):
    post = models.ForeignKey(GenericRelation)

在 SQL 中连接会复杂得多（django 可以帮助你），但它的性能也比简单的 OneToOne 连接低。仅当 OneToOne 连接严重损害应用程序的性能（这可能不太可能）时，您才需要采用此方法。

Answer 2

通用关系和外键是您成功之路上的朋友。定义一个中间模型，其中一侧是通用的，然后另一侧将获得多态模型的相关列表。它只是比标准 m2m 连接模型稍微复杂一点，因为通用侧有两列，一列对应 ContentType（实际上是 FK），另一列对应实际链接模型实例的 PK。您还可以使用标准 FK 参数限制要链接的模型。
你很快就会习惯它。

（现在我有了一个可以用来书写的实际键盘，这里有一个示例：）

class Post(models.Model):
    class Meta: abstract = True
    CONCRETE_CLASSES = ('announcement', 'event',)
    removed_from = generic.GenericRelation('OwnerRemovedPost',
        content_type_field='content_type',
        object_id_field='post_id',
    )

class Announcement(Post): pass

class Event(Post): pass

class Owner(models.Model):

    # non-polymorphic m2m
    added_events = models.ManyToManyField(Event, null=True)

    # polymorphic m2m-like property
    def removed_posts(self):
        # can't use ManyToManyField with through.
        # can't return a QuerySet b/c it would be a union.
        return [i.post for i in self.removed_post_items.all()]

    def removed_events(self):
        # using Post's GenericRelation
        return Event.objects.filter(removed_from__owner=self)


class OwnerRemovedPost(models.Model):
    content_type = models.ForeignKey(ContentType,
        limit_choices_to={'name__in': Post.CONCRETE_CLASSES},
    )
    post_id = models.PositiveIntegerField()
    post = generic.GenericForeignKey('content_type', 'post_id')
    owner = models.ForeignKey(Owner, related_name='removed_post_items')

    class Meta:
        unique_together = (('content_type', 'post_id'),)  # to fake FK constraint

您无法像经典的多对多那样过滤到相关集合，但可以使用 Owner，并巧妙地使用具体类的管理器，您可以到达您想要的任何地方。