檢查 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 查詢集仍然將它的視圖、共享等除以 2）所以這就是為什么我上面提到的用例(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 查詢集。

您可以使用子查詢來實現：

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周圍， 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 s）進行聚合，因此速度會非常慢。

不同的子查詢提供了獲得相同結果的更快方法。 它只對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而不是像我的示例中那樣只使用一個注釋，則將兩者分開可以避免為每個注釋重復子查詢。