Doktrin ORM: Filtrering af ManyToMany Queries med flere tags

Mestring af tag-baseret filtrering i Doctrin ORM-forespørgsler

Forestil dig, at du bygger en tilbudssøgningsfunktion, hvor brugere kan filtrere resultater ved hjælp af flere tags. 🏷️ I starten virker det ligetil – du skriver en forespørgsel, deltager i tabeller og forventer resultater. Men når du tilføjer flere tags, begynder forespørgslen at returnere tomme resultater eller opfører sig uventet.

Dette er en almindelig udfordring, som udviklere står over for i Doctrin ORM, når de beskæftiger sig med ManyToMany-relationer. Filtrering efter flere tags kræver præcision, især når man kombinerer WHERE-betingelser og logiske operationer som AND eller IN. Uden den rigtige tilgang, kan du kæmpe for at få ensartede resultater.

I et nyligt projekt stod jeg over for netop dette problem. En bruger skulle søge i citater, der indeholder alle valgte tags, ikke kun ét. Jeg prøvede AND-betingelser og IN()-sætninger, men forespørgselslogikken spillede ikke godt med Doctrines forespørgselsbygger. Det fik mig til at klø mig i hovedet, indtil jeg fandt løsningen. 💡

I denne artikel vil jeg lede dig gennem, hvordan du indsnævrer forespørgsler i et ManyToMany-forhold ved hjælp af Doctrin ORM. Uanset om du filtrerer efter flere tags med "AND"-logik eller arbejder med tilpasset forespørgselslogik, vil jeg dele et klart, fungerende eksempel for at hjælpe dig med at implementere dette effektivt. Lad os dykke ned! 🚀

Sådan filtreres citater i Doctrine ORM ved hjælp af tags

I backend, filtrering af citater efter flere tags kræver omhyggelig opbygning af forespørgsler, når du arbejder med ManyToMany-relationer. Scriptet starter med en forespørgselsbygger oprettet ved hjælp af `createQueryBuilder`-metoden. Det er her basisenheden ('citat') er valgt. For at filtrere anførselstegn baseret på tags, forbinder kommandoen `leftJoin` `tags`-entiteten til citationstabellen, hvilket giver os mulighed for at anvende betingelser på de relaterede tags. Hvis brugeren anmoder om filtrering ved hjælp af ELLER-logik, bruger vi `IN()`-sætningen til at matche anførselstegn med et af de valgte tags.

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()->Men i tilfælde, hvor anførselstegn skal matche alle de angivne tags (AND-logik), kommer `expr()->andX()`-metoden i spil. Denne metode lader os tilføje flere lighedsbetingelser ved hjælp af `expr()->eq()`, hvor hvert tag-id skal matche et relateret tag. Forespørgslen sikrer, at kun tilbud, der indeholder alle de angivne tags, returneres. Denne tilgang løser det almindelige problem, hvor filtrering efter flere tags ikke giver resultater på grund af forkert forespørgselskonstruktion.

På frontenden sender JavaScript-hentefunktionen dynamisk brugerens valgte tags til backend. For eksempel, hvis brugeren vælger tags 88 og 306, er disse id'er inkluderet i JSON-anmodningen. Backend'en behandler denne anmodning, bygger forespørgslen med de passende betingelser og returnerer de filtrerede resultater. Denne to-vejs interaktion sikrer en smidig brugeroplevelse, hvor søgningen opdateres dynamisk baseret på brugerinput. 🚀

For at forbedre forespørgselsydeevnen kan SQL-kommandoer som "GROUP BY" og "HAVING COUNT" bruges direkte for at sikre, at tags matcher korrekt. Ved at gruppere citater og tælle de forskellige tags, der er knyttet til dem, bortfiltrerer forespørgslen alle citater, der ikke opfylder kriterierne for tagtælling. Derudover sikrer brugen af ​​`setFirstResult` og `setMaxResults` korrekt paginering, hvilket forbedrer ydeevnen ved håndtering af store datasæt. Denne metode fungerer godt i scenarier, hvor brugere søger efter specifikke, filtrerede resultater blandt en stor pulje af citater. 😊

// 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());
        }
    }
}

Doktrin ORM: Kommandoer og koncepter til filtrering af ManyToMany Queries

Optimering af Doctrin ORM til komplekse tag-baserede forespørgsler

Når man arbejder med MangeTilMange relationer i Doctrin ORM er et overset aspekt forespørgselsoptimering. Mens grundlæggende filtre, der bruger "AND" eller "IN", er tilstrækkelige i små datasæt, kan ydeevnen forringes, efterhånden som databasen vokser. At optimere forespørgsler for at returnere nøjagtige resultater effektivt bliver kritisk. Når du f.eks. filtrerer citater efter flere tags, kan tilføjelse af indeksering på de relaterede tabeller (f.eks. `quote_tag` og `tag`) reducere udførelsestiden for forespørgsler betydeligt. Uden ordentlig indeksering udfører databasen fulde scanninger, som er ressourcekrævende.

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()->En anden afgørende optimering er at reducere unødvendige sammenføjninger. For eksempel, når du kun har brug for tilbuds-id'er, der matcher alle valgte tags, kan du hente ID'er med en enkelt forespørgsel ved at bruge `GROUP BY` og `HAVING COUNT`. Dette undgår at hente hele rækker og minimerer hukommelsesforbrug. Derudover kan forespørgselsbyggerens `expr()->andX()`-metode erstattes med optimeret rå SQL til storskalafiltrering. Brug af rå SQL kan nogle gange omgå Doctrin overhead, mens den samme funktionalitet opnås.

Doctrines caching-mekanisme er et andet værktøj til at optimere tag-baseret filtrering. Ved at aktivere resultatcache undgår gentagne søgninger med identiske betingelser genudførelse af forespørgslen. Dette er især nyttigt i scenarier, hvor dataene ikke ændres ofte. Ved at kombinere disse strategier—indeksering, forespørgselsoptimering og cachelagring – sikrer, at ManyToMany-forespørgsler til filtrering af tags forbliver hurtige og skalerbare. Korrekt implementering af disse teknikker hjælper udviklere med at undgå flaskehalse, efterhånden som applikationen og databasen vokser. 🚀