Doctrine ORM: Filtrando consultas ManyToMany com múltiplas tags

Dominando a filtragem baseada em tags em consultas ORM do Doctrine

Imagine que você está construindo um recurso de pesquisa de cotações onde os usuários podem filtrar os resultados usando várias tags. 🏷️ A princípio, parece simples: você escreve uma consulta, junta tabelas e espera resultados. No entanto, quando você adiciona várias tags, a consulta começa a retornar resultados vazios ou se comporta de forma inesperada.

Este é um desafio comum que os desenvolvedores enfrentam no Doctrine ORM ao lidar com relacionamentos ManyToMany. Filtrar por múltiplas tags requer precisão, especialmente ao combinar condições WHERE e operações lógicas como AND ou IN. Sem a abordagem correta, você poderá ter dificuldades para obter resultados consistentes.

Em um projeto recente, enfrentei exatamente esse problema. Um usuário precisava pesquisar cotações contendo todas as tags selecionadas, não apenas uma. Tentei condições AND e cláusulas IN(), mas a lógica de consulta não funcionou bem com o construtor de consultas do Doctrine. Isso me deixou coçando a cabeça até encontrar a solução. 💡

Neste artigo, mostrarei como restringir consultas em um relacionamento ManyToMany usando Doctrine ORM. Esteja você filtrando por várias tags com lógica "AND" ou trabalhando com lógica de consulta personalizada, compartilharei um exemplo prático e claro para ajudá-lo a implementar isso de maneira eficaz. Vamos mergulhar! 🚀

Como filtrar citações no Doctrine ORM usando tags

No back-end, filtrar cotações por várias tags requer construção cuidadosa de consultas ao trabalhar com relacionamentos ManyToMany. O script começa com um construtor de consultas criado usando o método `createQueryBuilder`. É aqui que a entidade base (`quote`) é selecionada. Para filtrar as cotações com base em tags, o comando `leftJoin` conecta a entidade `tags` à tabela de cotações, permitindo-nos aplicar condições nas tags relacionadas. Se o usuário solicitar filtragem usando a lógica OR, usaremos a cláusula `IN()` para combinar aspas com qualquer uma das tags selecionadas.

However, in cases where quotes need to match all the provided tags (AND logic), the `expr()->andX()` method comes into play. This method lets us add multiple equality conditions using `expr()->No entanto, nos casos em que as cotações precisam corresponder a todas as tags fornecidas (lógica AND), o método `expr()->andX()` entra em ação. Este método nos permite adicionar múltiplas condições de igualdade usando `expr()->eq()`, onde cada ID de tag deve corresponder a uma tag relacionada. A consulta garante que apenas aspas contendo todas as tags especificadas sejam retornadas. Essa abordagem resolve o problema comum em que a filtragem por múltiplas tags não retorna resultados devido à construção inadequada da consulta.

No front-end, a função de busca do JavaScript envia dinamicamente as tags selecionadas pelo usuário para o back-end. Por exemplo, se o usuário selecionar as tags 88 e 306, esses IDs serão incluídos na solicitação JSON. O back-end processa essa solicitação, cria a consulta com as condições apropriadas e retorna os resultados filtrados. Essa interação bidirecional garante uma experiência de usuário tranquila, onde a pesquisa é atualizada dinamicamente com base na entrada do usuário. 🚀

Para melhorar o desempenho da consulta, comandos SQL como `GROUP BY` e `HAVING COUNT` podem ser usados ​​diretamente para garantir que as tags correspondam corretamente. Ao agrupar cotações e contar as tags distintas associadas a elas, a consulta filtra quaisquer cotações que não atendam aos critérios de contagem de tags. Além disso, o uso de `setFirstResult` e `setMaxResults` garante paginação adequada, o que melhora o desempenho ao lidar com grandes conjuntos de dados. Este método funciona bem em cenários em que os usuários procuram resultados filtrados específicos entre um grande conjunto de cotações. 😊

// 1. Backend PHP solution to filter results using multiple tags in Doctrine ORM
$search = $request->request->all()['quote_search'];
$queryBuilder = $this->createQueryBuilder('q');
// Check if tag mode and tags are set
if ($search['tagMode'] != -1 && !empty($search['tags'])) {
    $queryBuilder->leftJoin('q.tags', 't');
    if ($search['tagMode'] == 1000) { // OR logic using IN()
        $queryBuilder->setParameter("tags", $search['tags']);
        $queryBuilder->andWhere("t.id IN (:tags)");
    } else if ($search['tagMode'] == 2000) { // AND logic for multiple tags
        $andExpr = $queryBuilder->expr()->andX();
        foreach ($search['tags'] as $tagId) {
            $andExpr->add($queryBuilder->expr()->eq("t.id", $tagId));
        }
        $queryBuilder->andWhere($andExpr);
    }
}
// Set pagination and ordering
$queryBuilder
    ->orderBy('q.id', 'ASC')
    ->setFirstResult($page * $limit)
    ->setMaxResults($limit);
$quotes = $queryBuilder->getQuery()->getResult();

SELECT q.id, q.content
FROM quote q
JOIN quote_tag qt ON q.id = qt.quote_id
JOIN tag t ON t.id = qt.tag_id
WHERE t.id IN (88, 306)
GROUP BY q.id
HAVING COUNT(DISTINCT t.id) = 2
ORDER BY q.id ASC
LIMIT 10 OFFSET 0;

// Assume user selects tags and submits the form
const selectedTags = [88, 306];
const tagMode = 2000; // AND mode
const data = {
    quote_search: {
        tagMode: tagMode,
        tags: selectedTags
    }
};
// Send tags to the backend via fetch
fetch('/quotes/filter', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(data)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

use PHPUnit\Framework\TestCase;
use Doctrine\ORM\EntityManager;
class QuoteRepositoryTest extends TestCase {
    public function testFilterQuotesByMultipleTags() {
        $entityManager = $this->createMock(EntityManager::class);
        $repo = new QuoteRepository($entityManager);
        $search = [
            'tagMode' => 2000,
            'tags' => [88, 306]
        ];
        $quotes = $repo->filterByTags($search, 0, 10);
        $this->assertNotEmpty($quotes);
        foreach ($quotes as $quote) {
            $this->assertContains(88, $quote->getTagIds());
            $this->assertContains(306, $quote->getTagIds());
        }
    }
}

Doctrine ORM: comandos e conceitos para filtrar consultas ManyToMany

Otimizando o Doctrine ORM para consultas complexas baseadas em tags

Ao trabalhar com Relacionamentos muitos para muitos no Doctrine ORM, um aspecto negligenciado é a otimização de consultas. Embora os filtros básicos que usam `AND` ou `IN` sejam suficientes em pequenos conjuntos de dados, o desempenho pode diminuir à medida que o banco de dados cresce. Otimizar consultas para retornar resultados precisos com eficiência torna-se crítico. Por exemplo, ao filtrar cotações por múltiplas tags, adicionar indexação nas tabelas relacionadas (por exemplo, `quote_tag` e `tag`) pode reduzir significativamente o tempo de execução da consulta. Sem a indexação adequada, o banco de dados realiza varreduras completas, que são caras em termos de recursos.

Another crucial optimization is reducing unnecessary joins. For example, when you only need quote IDs that match all selected tags, you can retrieve IDs with a single query using `GROUP BY` and `HAVING COUNT`. This avoids fetching entire rows and minimizes memory usage. Additionally, the query builder’s `expr()->Outra otimização crucial é reduzir junções desnecessárias. Por exemplo, quando você só precisa de IDs de cotação que correspondam a todas as tags selecionadas, você pode recuperar IDs com uma única consulta usando `GROUP BY` e `HAVING COUNT`. Isso evita a busca de linhas inteiras e minimiza o uso de memória. Além disso, o método `expr()->andX()` do construtor de consultas pode ser substituído por SQL bruto otimizado para filtragem em grande escala. O uso de SQL bruto às vezes pode ignorar a sobrecarga do Doctrine e, ao mesmo tempo, obter a mesma funcionalidade.

O mecanismo de cache do Doctrine é outra ferramenta para otimizar a filtragem baseada em tags. Ao ativar o cache de resultados, pesquisas repetidas com condições idênticas evitam a reexecução da consulta. Isto é particularmente útil em cenários onde os dados não mudam frequentemente. Combinando essas estratégias -indexação, otimização de consulta e armazenamento em cache – garantem que as consultas ManyToMany para filtragem de tags permaneçam rápidas e escalonáveis. A implementação adequada dessas técnicas ajuda os desenvolvedores a evitar gargalos à medida que o aplicativo e o banco de dados crescem. 🚀