python - 检查 object_id 是否在 queryset.annotate Case When 参数中多次出现

Question

文档字段查找对我的情况没有帮助

我的查询现在看起来像什么

date_delta = 2

queryset = TrendData.objects.filter(owner__trend_type__mnemonic='posts', 
 date_trend__date__range=[date_from, date_to]).values('owner_id', 'owner__name')

queryset.annotate(owner_name=F('owner_id__name')).values('owner_name', 'owner_id').annotate(
    views = Sum(Case(When(owner_id__gt=1, then=F('views') / date_delta)), default=('views')...,
                output_field=IntegerField() )
)

queryset 输出如下所示:

{'owner_id': 1306, 'owner__name': 'Some name123'}, 
{'owner_id': 1307, 'owner__name': 'Somename as well'}, 
{'owner_id': 1308, 'owner__name': 'aand another name'}, 
{'owner_id': 1306, 'owner__name': 'Some name123'}

如您所见，有匹配的 owner_id，并且查询集 len() 是每天 100k，所以如果日期范围是 5 天，则查询集 len() == 500k。我的 models.py 看起来像这样

class Owner(models.Model):
    class Meta:
        verbose_name_plural = 'Objects'

    TREND_OWNERS = Choices('group', 'user')

    link = models.CharField(max_length=255)
    name = models.CharField(max_length=255)
    owner_type = models.CharField(choices=TREND_OWNERS, max_length=50)
    trend_type = models.ForeignKey(TrendType, on_delete=models.CASCADE)

    def __str__(self):
        return f'{self.link}[{self.trend_type}]'


class TrendData(models.Model):
    class Meta:
        verbose_name_plural = 'Trends'

    owner = models.ForeignKey(Owner, on_delete=models.CASCADE)
    views = models.IntegerField()
    views_u = models.IntegerField()
    likes = models.IntegerField()
    shares = models.IntegerField()
    interaction_rate = models.DecimalField(max_digits=20, decimal_places=10)
    mean_age = models.IntegerField()
    date_trend = models.DateTimeField()

我意识到它会正常工作，但它会出错，因为如果 owner_id 很好，它将除以 date_delta，在我的情况下，我希望 owner_id 在查询集中出现不止一次。我试过 owner_id__count__gt 但那不存在 :(

我很想知道是否有一种方法可以计算我的注释 Case(When()) 查询集中 owner_id 的出现次数。这将真正解决我的问题。如果它大于 1，我们除以 date_delta，否则我们保持原样

更新:

需要说明的是，这个注解做得很好，但是它也划分了一些我不想划分的查询(在我的例子中，非重复的 owner_id 查询集仍然将它的 View 、份额等除以 2)这样这就是为什么我使用上面提到的 Case(When())

queryset.values('owner__name', 'owner_id').annotate(
    views=Sum('views') / 2, 
    views_u=Sum('views_u') / 2, 
    likes=Sum('likes') / 2,
    shares=Sum('shares') / 2, 
    interaction_rate=Sum('interaction_rate') / 2,
    mean_age=Sum('mean_age') / 2)

更新#2这是我的逻辑，但在 python 中

json_output = []
for item in (queryset
                .values('owner__name', 'owner_id')
                .annotate(owner_count=Count('owner_id'))
                .annotate(views=Sum('views'), views_u=Sum('views_u'),
                            likes=Sum('likes'),
                            shares=Sum('shares'),
                            interaction_rate=Sum('interaction_rate'),
                            mean_age=Sum('mean_age')):
    if item['owner_count'] > 1:
        item['views'] = item['views'] / date_delta
        item['views_u'] = item['views_u'] / date_delta
        item['likes'] = item['likes'] / date_delta
        item['shares'] = item['shares'] / date_delta
        item['interaction_rate'] = '{:.10f}'.format(
            Decimal(item['interaction_rate']) / date_delta)
        item['mean_age'] = item['mean_age'] / date_delta
        json_output.append(item)
    else:
        json_output.append(item)

Answer 1

更新:事实证明我毕竟没有对此进行全面测试(我以为我有，抱歉)。您需要将 Case 包裹在 Sum 周围，反之(Sum 在 Case 周围)则不会无论 Django 版本如何都可以工作:

(queryset
    .values('owner', owner_name=F('owner__name'))
    .annotate(owner_count=Count('owner'))
    .annotate(views = Case(
        When(owner_count__gt=1,
             then=Sum(F('views') / date_delta)),
        default=Sum('views'),
        output_field=IntegerField()
    ))
)

一个细微的变化是使用子查询。 Raydel 的子查询计算每个 Owner 的 Trenddata 计数在原则上是可行的，但会非常慢，因为它对 Trenddata 中的每一行进行聚合>(不仅仅针对唯一的 Owner)。

不同的子查询提供了获得相同结果的更快方法。它只执行一次计算 Trenddata 中的 Owner 的繁重工作，然后检查每个 Trenddata 对象的所有者是否在列表中。我认为这应该仍然比我的第一个查询慢，但奇怪的是，它在我的简短测试中表现平平(大约 300 万行)。

(queryset
    .values('owner', owner_name=F('owner__name'))
    .annotate(multi=Case(
        When(owner__in=Subquery(TrendData.objects
                                    .values('owner')
                                    .annotate(cnt=Count('owner'))
                                    .filter(cnt__gt=0)
                                    .values('owner')), 
             then=1),
        default=0,
        output_field=IntegerField())
    ) 
    .annotate(views = Case(
        When(multi=1,
             then=Sum(F('views') / date_delta)),
        default=Sum('views'),
        output_field=IntegerField())
    )
)

您可以将两个注解合二为一，但是如果您要为多个注解重用 multi 而不是像我的示例中那样只使用一个注解，那么将这两个注解分开可以避免为每个注解重复子查询注释。