ORM doktrína: ManyToMany lekérdezések szűrése több címkével

Címke alapú szűrés elsajátítása a Doctrine ORM lekérdezésekben

Képzelje el, hogy egy árajánlatkereső funkciót épít, amelyben a felhasználók több címke használatával szűrhetik az eredményeket. 🏷️ Elsőre egyértelműnek tűnik – lekérdezést írsz, táblákat csatlakozol, és eredményeket vársz. Ha azonban több címkét ad hozzá, a lekérdezés üres eredményeket kezd visszaadni, vagy váratlanul viselkedik.

Ez egy gyakori kihívás, amellyel a fejlesztők szembesülnek a Doctrine ORM-ben, amikor a ManyToMany kapcsolatokkal foglalkoznak. A több címke alapján történő szűrés pontosságot igényel, különösen a WHERE feltételek és a logikai műveletek (például ÉS vagy IN) kombinálásakor. A megfelelő megközelítés nélkül nehézségekbe ütközhet, hogy következetes eredményeket érjen el.

Egy közelmúltbeli projektben pontosan ezzel a problémával szembesültem. A felhasználónak az összes kiválasztott címkét tartalmazó idézetek között kellett keresnie, nem csak egyet. Kipróbáltam az AND feltételeket és az IN() záradékokat, de a lekérdezési logika nem működött jól a Doctrine lekérdezéskészítőjével. Addig vakartam a fejem, amíg meg nem találtam a megoldást. 💡

Ebben a cikkben bemutatom, hogyan szűkítheti le a lekérdezéseket egy ManyToMany kapcsolatban a Doctrine ORM segítségével. Függetlenül attól, hogy több címkével és „ÉS” logikával szűr, vagy egyéni lekérdezési logikával dolgozik, megosztok egy világos, működő példát, amely segít ennek hatékony megvalósításában. Merüljünk el! 🚀

Idézetek szűrése a Doctrine ORM-ben címkék használatával

A háttérben az idézetek szűrése szerint több címkét körültekintő lekérdezésépítést igényel, amikor ManyToMany kapcsolatokkal dolgozik. A szkript a "createQueryBuilder" metódussal létrehozott lekérdezéskészítővel indul. Itt van kiválasztva az alap entitás ("idézet"). Az idézőjelek címkék alapján történő szűréséhez a "leftJoin" parancs összekapcsolja a "tags" entitást az idézőjeltáblázattal, lehetővé téve számunkra, hogy feltételeket alkalmazzunk a kapcsolódó címkékre. Ha a felhasználó szűrést kér a OR logika használatával, akkor az `IN() záradékot használjuk az idézőjeleknek a kiválasztott címkék bármelyikével való egyeztetésére.

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()->Azokban az esetekben azonban, amikor az idézőjeleknek meg kell felelniük az összes megadott címkének (ÉS logika), az `expr()->andX()` metódus lép működésbe. Ez a módszer lehetővé teszi, hogy több egyenlőségi feltételt adjunk hozzá az "expr()->eq()" használatával, ahol minden címkeazonosítónak meg kell egyeznie egy kapcsolódó címkével. A lekérdezés biztosítja, hogy csak az összes megadott címkét tartalmazó idézőjel kerüljön visszaadásra. Ez a megközelítés megoldja azt a gyakori problémát, amikor a több címkével történő szűrés nem ad eredményt a nem megfelelő lekérdezés felépítése miatt.

A kezelőfelületen a JavaScript lekérési funkciója dinamikusan elküldi a felhasználó által kiválasztott címkéket a háttérrendszernek. Például, ha a felhasználó kiválasztja a 88 és 306 címkéket, ezek az azonosítók szerepelnek a JSON-kérésben. A háttérrendszer feldolgozza ezt a kérést, összeállítja a lekérdezést a megfelelő feltételekkel, és visszaadja a szűrt eredményeket. Ez a kétirányú interakció zökkenőmentes felhasználói élményt biztosít, ahol a keresés dinamikusan frissül a felhasználói bevitel alapján. 🚀

A jobb lekérdezési teljesítmény érdekében az olyan SQL-parancsok, mint a "GROUP BY" és a "HAVING COUNT", közvetlenül használhatók a címkék megfelelő illeszkedésének biztosítására. Az idézőjelek csoportosításával és a hozzájuk társított különálló címkék megszámlálásával a lekérdezés kiszűr minden olyan idézetet, amely nem felel meg a címkeszámlálási feltételeknek. Ezenkívül a "setFirstResult" és a "setMaxResults" használata megfelelő lapozást biztosít, ami javítja a teljesítményt nagy adatkészletek kezelésekor. Ez a módszer jól működik olyan forgatókönyvekben, amikor a felhasználók konkrét, szűrt találatokra keresnek nagy mennyiségű idézet között. 😊

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

ORM doktrína: Parancsok és fogalmak a ManyToMany lekérdezések szűréséhez

A Doctrine ORM optimalizálása összetett címke-alapú lekérdezésekhez

Amikor dolgozik ManyToMany kapcsolatok a Doctrine ORM-ben egy figyelmen kívül hagyott szempont a lekérdezés optimalizálás. Míg az "AND" vagy "IN" szűrőket használó alapvető szűrők elegendőek kis adatkészletekben, a teljesítmény az adatbázis növekedésével csökkenhet. Kritikussá válik a lekérdezések optimalizálása a pontos eredmények hatékony visszaadásához. Ha például az idézőjeleket több címke alapján szűri, az indexelés hozzáadása a kapcsolódó táblákhoz (pl. "quote_tag" és "tag") jelentősen csökkentheti a lekérdezés végrehajtási idejét. Megfelelő indexelés nélkül az adatbázis teljes vizsgálatot végez, ami erőforrások szempontjából költséges.

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()->Egy másik kulcsfontosságú optimalizálás a szükségtelen csatlakozások csökkentése. Például, ha csak olyan idézetazonosítókra van szüksége, amelyek megfelelnek az összes kiválasztott címkének, egyetlen lekérdezéssel is lekérheti az azonosítókat a "GROUP BY" és a "HAVING COUNT" használatával. Ez elkerüli a teljes sorok lekérését, és minimalizálja a memóriahasználatot. Ezenkívül a lekérdezéskészítő `expr()->andX()` metódusa lecserélhető optimalizált nyers SQL-re a nagyméretű szűréshez. A nyers SQL használata néha megkerülheti a Doctrine overheadet, miközben ugyanazt a funkciót éri el.

A Doctrine gyorsítótárazási mechanizmusa egy másik eszköz a címkealapú szűrés optimalizálására. Az eredmények gyorsítótárazásának engedélyezésével az azonos feltételekkel végzett ismételt keresések elkerülik a lekérdezés újbóli végrehajtását. Ez különösen hasznos olyan esetekben, amikor az adatok nem változnak gyakran. Ezeket a stratégiákat kombinálvaindexelés, lekérdezésoptimalizálás és gyorsítótárazás – biztosítja, hogy a címkék szűrésére szolgáló ManyToMany lekérdezések gyorsak és méretezhetőek maradjanak. E technikák megfelelő megvalósítása segít a fejlesztőknek elkerülni a szűk keresztmetszetek kialakulását az alkalmazás és az adatbázis növekedésével. 🚀