સિદ્ધાંત ORM: બહુવિધ ટૅગ્સ સાથે ઘણી બધી ક્વેરીઝને ફિલ્ટર કરવી

સિદ્ધાંત ORM ક્વેરીઝમાં ટેગ-આધારિત ફિલ્ટરિંગમાં નિપુણતા

કલ્પના કરો કે તમે ક્વોટ શોધ સુવિધા બનાવી રહ્યાં છો જ્યાં વપરાશકર્તાઓ બહુવિધ ટૅગ્સનો ઉપયોગ કરીને પરિણામોને ફિલ્ટર કરી શકે છે. 🏷️ શરૂઆતમાં, તે સીધું લાગે છે—તમે ક્વેરી લખો, કોષ્ટકોમાં જોડાઓ અને પરિણામોની અપેક્ષા રાખો. જો કે, જ્યારે તમે બહુવિધ ટૅગ્સ ઉમેરો છો, ત્યારે ક્વેરી ખાલી પરિણામો આપવાનું શરૂ કરે છે અથવા અનપેક્ષિત રીતે વર્તે છે.

MyToMany સંબંધો સાથે કામ કરતી વખતે સિદ્ધાંત ORMમાં વિકાસકર્તાઓને આ એક સામાન્ય પડકારનો સામનો કરવો પડે છે. બહુવિધ ટૅગ્સ દ્વારા ફિલ્ટર કરવા માટે ચોકસાઈની જરૂર છે, ખાસ કરીને જ્યારે WHERE શરતો અને AND અથવા IN જેવા તાર્કિક ઑપરેશન્સનું સંયોજન કરતી વખતે. યોગ્ય અભિગમ વિના, તમે સતત પરિણામો મેળવવા માટે સંઘર્ષ કરી શકો છો.

તાજેતરના પ્રોજેક્ટમાં, મને આ ચોક્કસ સમસ્યાનો સામનો કરવો પડ્યો. વપરાશકર્તાને માત્ર એક જ નહીં પરંતુ તમામ પસંદ કરેલા ટૅગ્સ ધરાવતા અવતરણ શોધવાની જરૂર છે. મેં AND શરતો અને IN() કલમો અજમાવી, પરંતુ ક્વેરી તર્ક સિદ્ધાંતના ક્વેરી બિલ્ડર સાથે સરસ ચાલ્યો ન હતો. જ્યાં સુધી મને ઉકેલ ન મળે ત્યાં સુધી તે મને માથું ખંજવાળતો રહ્યો. 💡

આ લેખમાં, હું તમને સિદ્ધાંત ORM નો ઉપયોગ કરીને MyToMany સંબંધમાં પ્રશ્નોને કેવી રીતે સાંકડી શકાય તે વિશે લઈ જઈશ. ભલે તમે "AND" તર્ક સાથે બહુવિધ ટૅગ્સ દ્વારા ફિલ્ટર કરી રહ્યાં હોવ અથવા કસ્ટમ ક્વેરી લોજિક સાથે કામ કરી રહ્યાં હોવ, આને અસરકારક રીતે અમલમાં મૂકવામાં તમારી સહાય માટે હું એક સ્પષ્ટ, કાર્યકારી ઉદાહરણ શેર કરીશ. ચાલો અંદર જઈએ! 🚀

ટૅગ્સનો ઉપયોગ કરીને સિદ્ધાંત ORM માં અવતરણોને કેવી રીતે ફિલ્ટર કરવું

બેકએન્ડમાં, દ્વારા અવતરણ ફિલ્ટર કરવું બહુવિધ ટૅગ્સ ManyToMany સંબંધો સાથે કામ કરતી વખતે સાવચેત ક્વેરી બિલ્ડિંગની જરૂર છે. સ્ક્રિપ્ટ `createQueryBuilder` પદ્ધતિનો ઉપયોગ કરીને બનાવેલ ક્વેરી બિલ્ડરથી શરૂ થાય છે. આ તે છે જ્યાં આધાર એન્ટિટી (`અવતરણ') પસંદ કરવામાં આવે છે. ટૅગ્સ પર આધારિત અવતરણોને ફિલ્ટર કરવા માટે, `leftJoin` આદેશ `ટેગ્સ` એન્ટિટીને અવતરણ કોષ્ટક સાથે જોડે છે, જે અમને સંબંધિત ટૅગ્સ પર શરતો લાગુ કરવાની મંજૂરી આપે છે. જો વપરાશકર્તા અથવા તર્કનો ઉપયોગ કરીને ફિલ્ટરિંગની વિનંતી કરે છે, તો અમે પસંદ કરેલા કોઈપણ ટૅગ સાથે અવતરણોને મેચ કરવા માટે `IN()` કલમનો ઉપયોગ કરીએ છીએ.

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()->જો કે, એવા કિસ્સામાં કે જ્યાં અવતરણને આપેલા તમામ ટૅગ્સ (AND લોજિક) સાથે મેળ ખાવું જરૂરી છે, `expr()->andX()` પદ્ધતિ અમલમાં આવે છે. આ પદ્ધતિ અમને `expr()->eq()` નો ઉપયોગ કરીને બહુવિધ સમાનતા શરતો ઉમેરવા દે છે, જ્યાં દરેક ટૅગ ID સંબંધિત ટૅગ સાથે મેળ ખાતી હોવી જોઈએ. ક્વેરી એ સુનિશ્ચિત કરે છે કે તમામ ઉલ્લેખિત ટૅગ્સ ધરાવતા અવતરણો જ પરત કરવામાં આવે છે. આ અભિગમ સામાન્ય સમસ્યાને હલ કરે છે જ્યાં બહુવિધ ટૅગ્સ દ્વારા ફિલ્ટર કરવાથી અયોગ્ય ક્વેરી બાંધકામને કારણે કોઈ પરિણામ મળતું નથી.

આગળના છેડે, JavaScript ફેચ ફંક્શન ગતિશીલ રીતે વપરાશકર્તાના પસંદ કરેલા ટૅગ્સને બેકએન્ડ પર મોકલે છે. દાખલા તરીકે, જો વપરાશકર્તા 88 અને 306 ટૅગ પસંદ કરે છે, તો આ ID JSON વિનંતીમાં શામેલ છે. બેકએન્ડ આ વિનંતી પર પ્રક્રિયા કરે છે, યોગ્ય શરતો સાથે ક્વેરી બનાવે છે અને ફિલ્ટર કરેલા પરિણામો આપે છે. આ દ્વિ-માર્ગીય ક્રિયાપ્રતિક્રિયા એક સરળ વપરાશકર્તા અનુભવની ખાતરી કરે છે જ્યાં વપરાશકર્તા ઇનપુટના આધારે શોધ ગતિશીલ રીતે અપડેટ થાય છે. 🚀

સુધારેલ ક્વેરી કામગીરી માટે, ટૅગ્સ યોગ્ય રીતે મેળ ખાય છે તેની ખાતરી કરવા માટે `GROUP BY` અને `HAVING COUNT` જેવા SQL આદેશોનો સીધો ઉપયોગ કરી શકાય છે. અવતરણોને જૂથબદ્ધ કરીને અને તેમની સાથે સંકળાયેલ અલગ-અલગ ટૅગ્સની ગણતરી કરીને, ક્વેરી એવા કોઈપણ અવતરણને ફિલ્ટર કરે છે જે ટૅગ ગણતરીના માપદંડને પૂર્ણ કરતા નથી. વધુમાં, `setFirstResult` અને `setMaxResults` નો ઉપયોગ યોગ્ય પૃષ્ઠાંકન સુનિશ્ચિત કરે છે, જે મોટા ડેટાસેટ્સને હેન્ડલ કરતી વખતે પ્રદર્શનમાં સુધારો કરે છે. આ પદ્ધતિ એવા સંજોગોમાં સારી રીતે કામ કરે છે જ્યાં વપરાશકર્તાઓ અવતરણના વિશાળ પૂલ વચ્ચે ચોક્કસ, ફિલ્ટર કરેલા પરિણામો શોધે છે. 😊

// 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: ઘણી બધી ક્વેરીઝને ફિલ્ટર કરવા માટેના આદેશો અને ખ્યાલો

જટિલ ટૅગ-આધારિત ક્વેરીઝ માટે ઑપ્ટિમાઇઝ સિદ્ધાંત ORM

સાથે કામ કરતી વખતે ઘણા બધા સંબંધો સિદ્ધાંત ORM માં, એક અવગણવામાં આવતું પાસું ક્વેરી ઑપ્ટિમાઇઝેશન છે. જ્યારે `AND` અથવા `IN` નો ઉપયોગ કરતા મૂળભૂત ફિલ્ટર્સ નાના ડેટાસેટ્સમાં પૂરતા હોય છે, જ્યારે ડેટાબેઝ વધે તેમ કામગીરી બગડી શકે છે. સચોટ પરિણામો પરત કરવા માટે ક્વેરીઝને ઑપ્ટિમાઇઝ કરવું એ મહત્ત્વપૂર્ણ બની જાય છે. દાખલા તરીકે, જ્યારે બહુવિધ ટૅગ્સ દ્વારા અવતરણ ફિલ્ટર કરતી વખતે, સંબંધિત કોષ્ટકો પર અનુક્રમણિકા ઉમેરવાથી (દા.ત., `ક્વોટ_ટૅગ` અને `ટૅગ`) ક્વેરી એક્ઝિક્યુશન સમયને નોંધપાત્ર રીતે ઘટાડી શકે છે. યોગ્ય અનુક્રમણિકા વિના, ડેટાબેઝ સંપૂર્ણ સ્કેન કરે છે, જે સંસાધનોની દ્રષ્ટિએ ખર્ચાળ છે.

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()->અન્ય નિર્ણાયક ઑપ્ટિમાઇઝેશન એ બિનજરૂરી જોડાઓને ઘટાડવાનું છે. ઉદાહરણ તરીકે, જ્યારે તમને બધા પસંદ કરેલા ટૅગ્સ સાથે મેળ ખાતા ક્વોટ IDની જરૂર હોય, ત્યારે તમે `GROUP BY` અને `HAVING COUNT` નો ઉપયોગ કરીને એક જ ક્વેરી સાથે ID પુનઃપ્રાપ્ત કરી શકો છો. આ સમગ્ર પંક્તિઓ લાવવાનું ટાળે છે અને મેમરી વપરાશને ઘટાડે છે. વધુમાં, ક્વેરી બિલ્ડરની `expr()->andX()` પદ્ધતિને મોટા પાયે ફિલ્ટરિંગ માટે ઑપ્ટિમાઇઝ કાચા SQL સાથે બદલી શકાય છે. સમાન કાર્યક્ષમતા હાંસલ કરતી વખતે કાચો SQL નો ઉપયોગ કેટલીકવાર સિદ્ધાંતના ઓવરહેડને બાયપાસ કરી શકે છે.

ટેગ-આધારિત ફિલ્ટરિંગને ઑપ્ટિમાઇઝ કરવા માટે સિદ્ધાંતની કેશીંગ મિકેનિઝમ એ બીજું સાધન છે. પરિણામ કેશીંગને સક્ષમ કરીને, સમાન પરિસ્થિતિઓ સાથે પુનરાવર્તિત શોધો ક્વેરી ફરીથી ચલાવવાનું ટાળે છે. આ ખાસ કરીને એવા સંજોગોમાં ઉપયોગી છે જ્યાં ડેટા વારંવાર બદલાતો નથી. આ વ્યૂહરચનાઓનું સંયોજન-અનુક્રમણિકા, ક્વેરી ઓપ્ટિમાઇઝેશન અને કેશીંગ—સુનિશ્ચિત કરે છે કે ફિલ્ટરિંગ ટૅગ્સ માટેની ManyToMany ક્વેરીઝ ઝડપી અને સ્કેલેબલ રહે છે. આ તકનીકોનો યોગ્ય અમલીકરણ વિકાસકર્તાઓને એપ્લિકેશન અને ડેટાબેઝની વૃદ્ધિ સાથે અવરોધોને ટાળવામાં મદદ કરે છે. 🚀