Doktrine ORM: Filtrering av ManyToMany Queries med flere tagger

Mestring av tag-basert filtrering i Doctrine ORM Queries

Tenk deg at du bygger en sitatsøkefunksjon der brukere kan filtrere resultater ved hjelp av flere tagger. 🏷️ Til å begynne med virker det enkelt – du skriver et søk, blir med i tabeller og forventer resultater. Men når du legger til flere tagger, begynner spørringen å returnere tomme resultater eller oppfører seg uventet.

Dette er en vanlig utfordring utviklere møter i Doctrine ORM når de håndterer ManyToMany-relasjoner. Filtrering etter flere tagger krever presisjon, spesielt når du kombinerer WHERE-forhold og logiske operasjoner som AND eller IN. Uten den riktige tilnærmingen kan du slite med å få konsistente resultater.

I et nylig prosjekt møtte jeg akkurat dette problemet. En bruker måtte søke i sitater som inneholder alle valgte tagger, ikke bare én. Jeg prøvde AND-betingelser og IN()-klausuler, men spørringslogikken spilte ikke bra med Doctrines spørringsbygger. Det fikk meg til å klø meg i hodet til jeg fant løsningen. 💡

I denne artikkelen skal jeg lede deg gjennom hvordan du kan begrense søkene i et ManyToMany-forhold ved å bruke Doctrine ORM. Enten du filtrerer etter flere tagger med «AND»-logikk eller arbeider med tilpasset spørringslogikk, vil jeg dele et tydelig, fungerende eksempel for å hjelpe deg med å implementere dette effektivt. La oss dykke inn! 🚀

Hvordan filtrere sitater i Doctrine ORM ved hjelp av koder

I backend, filtrering av sitater etter flere tagger krever nøye oppbygging av spørringer når du arbeider med ManyToMany-relasjoner. Skriptet starter med en spørringsbygger opprettet ved hjelp av `createQueryBuilder`-metoden. Det er her basisenheten (`quote`) er valgt. For å filtrere sitatene basert på tagger, kobler `leftJoin`-kommandoen `tags`-enheten til sitattabellen, slik at vi kan bruke betingelser på de relaterte kodene. Hvis brukeren ber om filtrering ved hjelp av ELLER-logikk, bruker vi `IN()`-leddet for å matche anførselstegn med hvilken som helst av de valgte taggene.

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 tilfeller der anførselstegn må samsvare med alle de angitte kodene (AND-logikk), kommer `expr()->andX()`-metoden inn i bildet. Denne metoden lar oss legge til flere likhetsbetingelser ved å bruke `expr()->eq()`, der hver tag-ID må samsvare med en relatert kode. Spørringen sikrer at kun anførselstegn som inneholder alle de angitte kodene returneres. Denne tilnærmingen løser det vanlige problemet der filtrering etter flere tagger ikke gir resultater på grunn av feil konstruksjon av spørringer.

På grensesnittet sender JavaScript-hentefunksjonen dynamisk brukerens valgte tagger til bakenden. Hvis brukeren for eksempel velger taggene 88 og 306, er disse ID-ene inkludert i JSON-forespørselen. Backend behandler denne forespørselen, bygger spørringen med de riktige betingelsene og returnerer de filtrerte resultatene. Denne toveis interaksjonen sikrer en jevn brukeropplevelse der søket oppdateres dynamisk basert på brukerinndata. 🚀

For forbedret søkeytelse kan SQL-kommandoer som "GROUP BY" og "HAVING COUNT" brukes direkte for å sikre at kodene samsvarer riktig. Ved å gruppere sitater og telle de forskjellige kodene knyttet til dem, filtrerer spørringen ut alle sitater som ikke oppfyller kriteriene for taggtelling. I tillegg sikrer bruken av `setFirstResult` og `setMaxResults` riktig paginering, noe som forbedrer ytelsen ved håndtering av store datasett. Denne metoden fungerer godt i scenarier der brukere søker etter spesifikke, filtrerte resultater blant et stort utvalg av sitater. 😊

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

Doktrine ORM: Kommandoer og konsepter for filtrering av ManyToMany Queries

Optimalisering av Doctrine ORM for komplekse tag-baserte søk

Når du jobber med MangeToMange relasjoner i Doctrine ORM er et oversett aspekt spørringsoptimalisering. Mens grunnleggende filtre som bruker "AND" eller "IN" er tilstrekkelig i små datasett, kan ytelsen reduseres etter hvert som databasen vokser. Å optimalisere spørringer for å returnere nøyaktige resultater effektivt blir kritisk. For eksempel, når du filtrerer anførselstegn etter flere tagger, kan det å legge til indeksering på de relaterte tabellene (f.eks. `quote_tag` og `tag`) redusere utføringstiden betraktelig. Uten riktig indeksering utfører databasen fullstendige skanninger, som er ressurskrevende.

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 annen viktig optimalisering er å redusere unødvendige sammenføyninger. For eksempel, når du bare trenger tilbuds-ID-er som samsvarer med alle valgte tagger, kan du hente ID-er med en enkelt spørring ved å bruke "GROUP BY" og "HAVING COUNT". Dette unngår å hente hele rader og minimerer minnebruken. I tillegg kan spørringsbyggerens `expr()->andX()`-metode erstattes med optimalisert rå SQL for storskalafiltrering. Bruk av rå SQL kan noen ganger omgå Doctrine-overhead samtidig som den samme funksjonaliteten oppnås.

Doctrines caching-mekanisme er et annet verktøy for å optimalisere tag-basert filtrering. Ved å aktivere resultatbufring unngår gjentatte søk med identiske betingelser å utføre spørringen på nytt. Dette er spesielt nyttig i scenarier der dataene ikke endres ofte. Ved å kombinere disse strategiene—indeksering, spørringsoptimalisering og hurtigbufring – sikrer at ManyToMany-spørringer for filtreringskoder forblir raske og skalerbare. Riktig implementering av disse teknikkene hjelper utviklere med å unngå flaskehalser etter hvert som applikasjonen og databasen vokser. 🚀