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且queryset len（）每天为100k，因此，如果日期范围为5天，queryset 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在queryset中出现多次。我已经尝试过owner_id__count__gt，但是不存在：（

我很想知道在我的注释Case(When())查询集中是否有一种方法来计算owner_id的出现。从字面上解决我的问题。如果它大于1大于我们除以date_delta的值，否则我们将其保持不变

更新：

请注意，此批注做得很好，但是它也划分了一些我不想划分的查询（在我的情况下，NONplicate owner_id queryset仍然将其视图，共享等划分为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

首先，我认为这是错误的owner_name=F('owner_id__name' owner_name=F('owner__name'。

据我了解，您想用具有所有者的TrendData实例的数量来注释TrendData查询集。

您可以使用Subquery来实现：

owner_td_count = Owner.objects.annotate(
    td_count=Count('trenddata_set')
).filter(
    id=OuterRef('owner_id')
).values('td_count')[:1]

然后首先通过计算owner_id的出现来注释：

queryset.annotate(
    owner_name=F('owner__name'),
    owner_id_count=Subquery(owner_td_count)   # How many DataTrend's have the owner with id=owner_id
    ).values('owner_name', 'owner_id').annotate(
        # ...
    )
)

那么您可以在案例中/建造时：

Case(
    When(
        owner_id_count=1, then=F('views'), 
        default=F('views') / date_delta)),
        output_field=IntegerField() 
    )
)

Answer 2

更新：事实证明，我毕竟还没有对此进行全面测试（我以为我道歉了）。您需要将Case包在Sum周围，否则，无论Django版本如何，{{1}周围都是Sum周围都是无效的：

Case

有一个小的变化是使用子查询。 Raydel的子查询原则上为每个(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() )) )计算Trenddata计数，但是由于它会为Owner中的每一行进行汇总，因此速度非常慢（不仅限于唯一的{{1 }} s。

不同的子查询提供了更快的获得相同结果的方法。它仅对Trenddata中的Owner个对象进行一次繁重的工作，然后检查其所有者是否在列表中，从而检查每个Owner对象。我认为这应该比我的第一个查询要慢，但奇怪的是，它在我的简短测试（大约300万行）中达到了标准。

Trenddata

您可以将两个注释合而为一，但是如果您重复使用Trenddata来获得更多注释，而不是像我的示例那样仅使用一个注释，则将这两个注释分开可以避免为每个注释重复子查询。 / p>

检查object_id是否在queryset中多次出现。注释参数

2 个答案: