Django ORM QuerySet 通过字段交集

Question

这些是我拥有的（伪）模型。

Blog:
  name
  etc...

Article:
  name
  blog
  creator
  etc

User (as per django.contrib.auth)

所以我的问题是这样的：我有两个用户。我想要获取两个用户在同一个博客（无论是哪个博客）上发布的所有文章。我不能简单地过滤两个用户的文章模型，因为这会产生两个用户创建的文章集。显然不是我想要的。但是我可以以某种方式过滤以获得对象的字段在两个查询集之间匹配的所有文章吗？

Answer 1

对于练习 Django 的 ORM 来说，这是一个很好的问题:-)

根据提前知道哪些参数，有几种方法可以解决这个问题。

场景 1：您了解用户和特定博客

如果您有一个特定的博客，并且想要简单地查找任一作者撰写的所有文章，您可以使用 Q 对象。我认为这不是您的场景，但为了以防万一，我将其放在这里：

from django.db.models import Q
Article.objects.filter(Q(creator=user1) | Q(creator=user2), blog=some_blog_instance)

场景 2：您只知道用户

如果您想查找两个用户都发布过的所有博客，并且然后想要找到他们在这些博客中发布了哪些文章，您需要从 Blog 模型开始：

from django.db.models import Q

# Find all blogs where both user1 and user2 have written articles
blogs = Blog.objects.filter(article__creator=user1).\
        filter(article__creator=user2).distinct()

# Now find which articles those were
for blog in blogs:
    articles = blog.article_set.filter(Q=(creator=user1) | Q=(creator=user2))

---

根据 Paulo 的评论进行编辑：

这是一组我认为与OP 的伪代码，它演示了上述代码的工作原理（至少在 sqlite3 和 postgres 上）：

from django.db import models
from django.contrib.auth.models import User

class Blog(models.Model):
    name = models.CharField(max_length=128)

class Article(models.Model):
    name = models.CharField(max_length=128)
    blog = models.ForeignKey(Blog)
    creator = models.ForeignKey(User)

然后是 user1 和 user2 在 blog2 上写文章的一些数据：

u1 = User.objects.create(username='u1')
u2 = User.objects.create(username='u2')

b1 = Blog.objects.create(name='b1')
b2 = Blog.objects.create(name='b2')
b3 = Blog.objects.create(name='b3')

b1_art1 = Article.objects.create(name='b1_art1', blog=b1, creator=u1)
b2_art1 = Article.objects.create(name='b2_art1', blog=b2, creator=u1)
b2_art2 = Article.objects.create(name='b2_art2', blog=b2, creator=u2)

查询：

[b.name for b in Blog.objects.filter(article__creator=user1).\
    filter(article__creator=user2).distinct()]

产生：

[b2]

SQL 是（我的测试 django 应用程序名为 foo） ：

SELECT "foo_blog"."id", "foo_blog"."name" 
FROM "foo_blog" 
INNER JOIN "foo_article" ON ("foo_blog"."id" = "foo_article"."blog_id") 
INNER JOIN "foo_article" T4 ON ("foo_blog"."id" = T4."blog_id") 
WHERE ("foo_article"."creator_id" = 1  AND T4."creator_id" = 2 )

因此，虽然 WHERE 子句确实有 (A AND B)，但 A 和 B 引用了不同的内部联接("foo_article"."creator_id" 与 T4."creator_id")，并且不是同一个表（这是 filter(A, B) 生成的表，(即： WHERE ("foo_article"."creator_id" = 1 and "foo_article"."creator_id" = 2))

（没有 distinct() 子句，如果您添加了任何一位作者的更多文章，您都会在查询集结果中获得多个 b2 条目。）

就像我说的，这是一个很棒的 ORM 练习！

Answer 2

我记得读过类似“Django ORM 85% 的情况下你能到达那里，另外 15% 的情况是 raw SQL" 在核心团队某人的演示中 - 但我再也找不到源代码了。

您的问题似乎适合 原始 SQL 的 15%< /a>.