Doctrine ORM: filtració de moltes consultes amb diverses etiquetes

Dominar el filtratge basat en etiquetes en consultes ORM de Doctrine

Imagineu que esteu creant una funció de cerca de pressupostos on els usuaris puguin filtrar els resultats mitjançant diverses etiquetes. 🏷️ Al principi, sembla senzill: escrius una consulta, uneixes taules i esperes resultats. Tanmateix, quan afegiu diverses etiquetes, la consulta comença a retornar resultats buits o es comporta de manera inesperada.

Aquest és un repte comú que s'enfronten els desenvolupadors a Doctrine ORM quan tracten amb Relacions ManyToMany. El filtratge per diverses etiquetes requereix precisió, especialment quan es combinen condicions WHERE i operacions lògiques com AND o IN. Sense l'enfocament adequat, és possible que tingueu problemes per obtenir resultats coherents.

En un projecte recent, em vaig enfrontar a aquest problema. Un usuari necessitava cercar quotes que contenguessin totes les etiquetes seleccionades, no només una. Vaig provar les condicions AND i les clàusules IN(), però la lògica de la consulta no va funcionar bé amb el creador de consultes de Doctrine. Em va deixar rascant el cap fins que vaig trobar la solució. 💡

En aquest article, us explicaré com reduir les consultes en una relació ManyToMany mitjançant Doctrine ORM. Tant si esteu filtrant per diverses etiquetes amb la lògica "I" com si treballeu amb una lògica de consulta personalitzada, compartiré un exemple clar i de treball per ajudar-vos a implementar-ho de manera eficaç. Submergem-nos! 🚀

Com filtrar cites a Doctrine ORM mitjançant etiquetes

Al fons, filtrant les cometes per múltiples etiquetes requereix una creació acurada de consultes quan es treballa amb relacions ManyToMany. L'script comença amb un generador de consultes creat amb el mètode `createQueryBuilder`. Aquí és on es selecciona l'entitat base ('quote'). Per filtrar les cometes basades en etiquetes, l'ordre `leftJoin` connecta l'entitat `tags` a la taula de cometes, la qual cosa ens permet aplicar condicions a les etiquetes relacionades. Si l'usuari sol·licita un filtratge mitjançant la lògica OR, fem servir la clàusula `IN()` per fer coincidir les cometes amb qualsevol de les etiquetes seleccionades.

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()->Tanmateix, en els casos en què les cometes han de coincidir amb totes les etiquetes proporcionades (I lògica), entra en joc el mètode `expr()->andX()`. Aquest mètode ens permet afegir diverses condicions d'igualtat mitjançant `expr()->eq()`, on cada identificador d'etiqueta ha de coincidir amb una etiqueta relacionada. La consulta garanteix que només es retornin cometes que contenen totes les etiquetes especificades. Aquest enfocament resol el problema comú en què el filtratge per diverses etiquetes no retorna cap resultat a causa d'una construcció incorrecta de la consulta.

A la part frontal, la funció d'obtenció de JavaScript envia dinàmicament les etiquetes seleccionades per l'usuari al backend. Per exemple, si l'usuari selecciona les etiquetes 88 i 306, aquests identificadors s'inclouen a la sol·licitud JSON. El backend processa aquesta sol·licitud, crea la consulta amb les condicions adequades i retorna els resultats filtrats. Aquesta interacció bidireccional garanteix una experiència d'usuari fluida on la cerca s'actualitza de manera dinàmica segons l'entrada de l'usuari. 🚀

Per millorar el rendiment de les consultes, les ordres SQL com `GROUP BY` i `HAVING COUNT` es poden utilitzar directament per garantir que les etiquetes coincideixen correctament. En agrupar les cometes i comptar les diferents etiquetes associades a elles, la consulta filtra totes les cometes que no compleixen els criteris de recompte d'etiquetes. A més, l'ús de `setFirstResult` i `setMaxResults` garanteix la paginació adequada, la qual cosa millora el rendiment quan es manegen grans conjunts de dades. Aquest mètode funciona bé en escenaris en què els usuaris cerquen resultats específics i filtrats entre un gran conjunt de cotitzacions. 😊

// 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: ordres i conceptes per filtrar moltes consultes

Optimització de Doctrine ORM per a consultes complexes basades en etiquetes

Quan es treballa amb ManyToMany relacions a Doctrine ORM, un aspecte passat per alt és l'optimització de consultes. Tot i que els filtres bàsics que utilitzen "AND" o "IN" són suficients en conjunts de dades petits, el rendiment es pot degradar a mesura que la base de dades creix. Optimitzar les consultes per retornar resultats precisos de manera eficient esdevé fonamental. Per exemple, quan es filtren cometes per diverses etiquetes, afegir indexació a les taules relacionades (p. ex., `quote_tag` i `tag`) pot reduir significativament el temps d'execució de la consulta. Sense una indexació adequada, la base de dades realitza exploracions completes, que són costoses en termes 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()->Una altra optimització crucial és reduir les unions innecessàries. Per exemple, quan només necessiteu identificadors de cites que coincideixin amb totes les etiquetes seleccionades, podeu recuperar els identificadors amb una sola consulta mitjançant `GROUP BY` i `HAVING COUNT`. Això evita obtenir files senceres i minimitza l'ús de memòria. A més, el mètode `expr()->andX()` del creador de consultes es pot substituir per SQL en brut optimitzat per al filtratge a gran escala. L'ús de SQL sense processar de vegades pot evitar la sobrecàrrega de Doctrine mentre s'aconsegueix la mateixa funcionalitat.

El mecanisme de memòria cau de Doctrine és una altra eina per optimitzar el filtratge basat en etiquetes. En activar la memòria cau dels resultats, les cerques repetides amb condicions idèntiques eviten tornar a executar la consulta. Això és especialment útil en escenaris on les dades no canvien amb freqüència. Combinant aquestes estratègies:indexació, optimització de consultes i memòria cau: garanteix que les consultes de ManyToMany per filtrar etiquetes siguin ràpides i escalables. La implementació adequada d'aquestes tècniques ajuda els desenvolupadors a evitar colls d'ampolla a mesura que l'aplicació i la base de dades creixen. 🚀