Início / coding / Perguntas / 79543609
Accepted
bur
Asked: 2025-03-30 01:03:40 +0800 CST

Usando StringAgg após filter e distinct

  • 772

Estou usando StringAgge orderda seguinte forma:

    # Get order column & annotate with list of credits
    if request.POST.get('order[0][name]'):
        order = request.POST['order[0][name]']
        if order == 'credits_primary':
            releases = releases.annotate(credits_primary=StringAgg(
                'credits__entity__name',
                delimiter=', ',
                filter=Q(credits__type='primary'),
                ordering='credits__id'
            ))
        elif order == 'credits_secondary':
            releases = releases.annotate(credits_secondary=StringAgg(
                'credits__entity__name',
                delimiter=', ',
                filter=Q(credits__type='secondary'),
                ordering='credits__id'
            ))
    else:
        order = 'title'
    
    # Order releases
    if request.POST.get('order[0][dir]') == 'desc':
        releases = releases.order_by(F(order).desc(nulls_last=True), 'title')
    else:
        releases = releases.order_by(F(order).asc(nulls_last=True), 'title')
    
    for release in releases:
        try: print(release.credits_primary)
        except: pass
        try: print(release.credits_secondary)
        except: pass

Isso por si só funciona exatamente como esperado: a ordem é o que eu espero e printretorna os valores que eu espero.

Entretanto, quando aplico um filterantes disso, onde o resultado inclui múltiplas instâncias do mesmo release, o credits__entity__names será repetido ou omitido para aquela versão, dependendo de quantos resultados houver para o(s) campo(s) que estão sendo filtrados, apesar de usar distinct.

Abaixo está o que filterestou aplicando que afeta a agregação (aplicado antes StringAgg):

    # Other filters...

    # Filter by Search
    if request.POST.get('search[value]'):
        query = Q()
        search = request.POST['search[value]']
        query.add(Q(title__icontains=search), Q.OR)
        query.add(Q(tags__tag__name__icontains=search), Q.OR)
        query.add(Q(credits__entity__name__icontains=search), Q.OR)
        releases = releases.filter(query)
        
    # Make sure items aren't repeated
    releases = releases.distinct()
django

2 respostas

  1. Não tenho certeza se entendi seu caso de uso, mas se o problema é que você obtém duplicatas em sua agregação, talvez você possa tentar usar distinctem suas agregações de strings:

    https://docs.djangoproject.com/fr/5.1/ref/contrib/postgres/gregtes/#stringagg

    • 1
  2. Best Answer

    Abaixo está o filtro que estou aplicando que afeta a agregação (aplicado antes do StringAgg):

    O filtro olha para (outras) relações um-para-muitos ou muitos-para-muitos. Isso significa que isso resultará em LEFT OUTER JOINque começará a agir como um multiplicador. O mesmo funciona com outros agregados, como SUMe COUNT.

    De fato, se você apenas agregar, a consulta ficará assim:

    SELECT string_agg(CASE
                      WHEN c.type = 'primary' THEN e.name
                      ELSE NULL
                  END
                  ORDER BY e.id)
FROM releases AS r
LEFT OUTER JOIN credits AS c ON c.release_id = r.id
LEFT OUTER JOIN entity AS e ON e.credit_id = e.id

    e isso é bom, porque queremos agregar as entidades, então, por versão, obtemos todas as entidades.

    Mas agora, se filtrarmos por exemplo pelas tags, fica assim:

    SELECT string_agg(CASE
                      WHEN c.type = 'primary' THEN e.name
                      ELSE NULL
                  END
                  ORDER BY e.id)
FROM releases AS r
LEFT OUTER JOIN credits AS c ON c.release_id = r.id
LEFT OUTER JOIN entity AS e ON e.credit_id = e.id
LEFT OUTER JOIN release_tag rt1 ON rt1.release_id = r.id
LEFT OUTER JOIN tag t1 ON rt1.tag_id = t1.id
LEFT OUTER JOIN release_tag rt2 ON rt2.release_id = r.id
LEFT OUTER JOIN tag t1 ON rt2.tag_id = t2.id
WHERE t1.name = 'tag1'
  OR t2.name = 'tag2'

    Isso significa que os nomes de entidade para uma versão em que uma das duas tags correspondem serão repetidos uma vez, mas onde ambas correspondem, serão incluídos duas vezes .

    O Q(credits__entity__name__icontains)que piora ainda mais a situação: isso será adicionado à tabela ce, portanto, entidades que creditstiverem duas ou mais correspondências serão incluídas muitas vezes, enquanto as entidades de uma versão que não corresponder a um determinado crédito não serão mais incluídas.

    O divisor menos comum de todos esses fenômenos é provavelmente que você deve ter muito cuidado ao fazer agregações quando fizer JOINs, especialmente se várias tabelas nas quais os JOINs são carregados estiverem envolvidas.

    O que você provavelmente pode fazer é criar uma Subqueryexpressão  [Django-doc] que, portanto, não seja impactada pelas tabelas "externas" e pelos arquivos JOIN.

    • 1

relate perguntas