கோட்பாடு ORM: பல குறிச்சொற்களுடன் பல கேள்விகளை வடிகட்டுதல்

கோட்பாட்டின் ORM வினவல்களில் குறிச்சொல் அடிப்படையிலான வடிகட்டலில் தேர்ச்சி பெறுதல்

பல குறிச்சொற்களைப் பயன்படுத்தி பயனர்கள் முடிவுகளை வடிகட்டக்கூடிய மேற்கோள் தேடல் அம்சத்தை நீங்கள் உருவாக்குகிறீர்கள் என்று கற்பனை செய்து பாருங்கள். 🏷️ முதலில், இது நேரடியானதாகத் தெரிகிறது-நீங்கள் வினவலை எழுதுங்கள், அட்டவணையில் சேருங்கள் மற்றும் முடிவுகளை எதிர்பார்க்கிறீர்கள். இருப்பினும், நீங்கள் பல குறிச்சொற்களைச் சேர்க்கும்போது, ​​வினவல் வெற்று முடிவுகளைத் தரத் தொடங்கும் அல்லது எதிர்பாராத விதமாகச் செயல்படும்.

பல பல உறவுகளுடன் கையாளும் போது, ​​டோக்ட்ரின் ORMல் டெவலப்பர்கள் எதிர்கொள்ளும் பொதுவான சவாலாகும். பல குறிச்சொற்கள் மூலம் வடிகட்டுவதற்கு துல்லியம் தேவைப்படுகிறது, குறிப்பாக எங்கே நிபந்தனைகள் மற்றும் AND அல்லது IN போன்ற தருக்க செயல்பாடுகளை இணைக்கும்போது. சரியான அணுகுமுறை இல்லாமல், நிலையான முடிவுகளைப் பெற நீங்கள் போராடலாம்.

சமீபத்திய திட்டத்தில், நான் இந்த சரியான சிக்கலை எதிர்கொண்டேன். தேர்ந்தெடுக்கப்பட்ட அனைத்து குறிச்சொற்களையும் கொண்ட மேற்கோள்களைத் தேட ஒரு பயனர் தேவை, ஒன்று மட்டும் அல்ல. நான் மற்றும் நிபந்தனைகள் மற்றும் IN() உட்பிரிவுகளை முயற்சித்தேன், ஆனால் டாக்ட்ரின் வினவல் பில்டருடன் வினவல் தர்க்கம் நன்றாக இல்லை. நான் தீர்வு காணும் வரை அது என் தலையை சொறிந்து கொண்டே இருந்தது. 💡

இந்தக் கட்டுரையில், டாக்ட்ரைன் ORM ஐப் பயன்படுத்தி பல பல உறவில் வினவல்களைக் குறைப்பது எப்படி என்பதை நான் உங்களுக்குக் கூறுகிறேன். நீங்கள் "மற்றும்" தர்க்கத்துடன் பல குறிச்சொற்கள் மூலம் வடிகட்டினாலும் அல்லது தனிப்பயன் வினவல் தர்க்கத்துடன் பணிபுரிந்தாலும், இதை திறம்பட செயல்படுத்த உங்களுக்கு உதவும் தெளிவான, செயல்படும் உதாரணத்தைப் பகிர்கிறேன். உள்ளே நுழைவோம்! 🚀

குறிச்சொற்களைப் பயன்படுத்தி கோட்பாட்டின் ORM இல் மேற்கோள்களை வடிகட்டுவது எப்படி

பின்தளத்தில், மேற்கோள்களை வடிகட்டுதல் பல குறிச்சொற்கள் பல உறவுகளுடன் பணிபுரியும் போது கவனமாக வினவுதல் தேவைப்படுகிறது. `createQueryBuilder` முறையைப் பயன்படுத்தி உருவாக்கப்பட்ட வினவல் பில்டருடன் ஸ்கிரிப்ட் தொடங்குகிறது. இங்குதான் அடிப்படை எண் (`quote`) தேர்ந்தெடுக்கப்பட்டது. குறிச்சொற்களின் அடிப்படையில் மேற்கோள்களை வடிகட்ட, `leftJoin` கட்டளையானது `tags` உட்பொருளை மேற்கோள் அட்டவணையுடன் இணைக்கிறது, இது தொடர்புடைய குறிச்சொற்களில் நிபந்தனைகளைப் பயன்படுத்த அனுமதிக்கிறது. அல்லது லாஜிக்ஐப் பயன்படுத்தி வடிகட்டுமாறு பயனர் கோரினால், தேர்ந்தெடுக்கப்பட்ட குறிச்சொற்களில் ஏதேனும் மேற்கோள்களுடன் பொருத்துவதற்கு `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()->இருப்பினும், வழங்கப்பட்ட அனைத்து குறிச்சொற்களுக்கும் (மற்றும் தர்க்கம்) மேற்கோள்கள் பொருந்த வேண்டிய சந்தர்ப்பங்களில், `expr()->andX()` முறை செயல்படும். இந்த முறையானது `expr()->eq()` ஐப் பயன்படுத்தி பல சமத்துவ நிலைகளைச் சேர்க்க உதவுகிறது, இதில் ஒவ்வொரு டேக் ஐடியும் தொடர்புடைய குறிச்சொல்லுடன் பொருந்த வேண்டும். வினவல் அனைத்து குறிப்பிட்ட குறிச்சொற்களையும் கொண்ட மேற்கோள்கள் மட்டுமே திரும்புவதை உறுதி செய்கிறது. முறையற்ற வினவல் கட்டுமானம் காரணமாக பல குறிச்சொற்கள் மூலம் வடிகட்டுதல் எந்த முடிவையும் தராத பொதுவான சிக்கலை இந்த அணுகுமுறை தீர்க்கிறது.

முன் முனையில், JavaScript பெறுதல் செயல்பாடு பயனரின் தேர்ந்தெடுக்கப்பட்ட குறிச்சொற்களை பின்தளத்திற்கு மாறும் வகையில் அனுப்புகிறது. எடுத்துக்காட்டாக, பயனர் 88 மற்றும் 306 குறிச்சொற்களைத் தேர்ந்தெடுத்தால், இந்த ஐடிகள் 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` ஐப் பயன்படுத்தும் அடிப்படை வடிப்பான்கள் போதுமானதாக இருந்தாலும், தரவுத்தளம் வளரும்போது செயல்திறன் குறையலாம். துல்லியமான முடிவுகளை திறம்பட வழங்க, வினவல்களை மேம்படுத்துவது முக்கியமானதாகிறது. உதாரணமாக, பல குறிச்சொற்கள் மூலம் மேற்கோள்களை வடிகட்டும்போது, ​​தொடர்புடைய அட்டவணைகளில் (எ.கா., `quote_tag` மற்றும் `tag`) அட்டவணைப்படுத்தல் சேர்ப்பது வினவல் செயலாக்க நேரத்தை கணிசமாகக் குறைக்கும். முறையான அட்டவணைப்படுத்தல் இல்லாமல், தரவுத்தளமானது முழு ஸ்கேன்களைச் செய்கிறது, அவை வளங்களின் அடிப்படையில் விலை அதிகம்.

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()->மற்றொரு முக்கியமான தேர்வுமுறை தேவையற்ற இணைப்புகளை குறைப்பதாகும். எடுத்துக்காட்டாக, தேர்ந்தெடுக்கப்பட்ட அனைத்து குறிச்சொற்களுக்கும் பொருந்தக்கூடிய மேற்கோள் ஐடிகள் மட்டுமே உங்களுக்குத் தேவைப்படும்போது, ​​`GROUP BY` மற்றும் `HAVING COUNT` ஐப் பயன்படுத்தி ஒரே வினவலின் மூலம் ஐடிகளை மீட்டெடுக்கலாம். இது முழு வரிசைகளையும் பெறுவதைத் தவிர்க்கிறது மற்றும் நினைவக பயன்பாட்டைக் குறைக்கிறது. கூடுதலாக, வினவல் பில்டரின் `expr()->andX()` முறையானது பெரிய அளவிலான வடிகட்டலுக்கு உகந்த மூல SQL உடன் மாற்றப்படும். மூல SQL ஐப் பயன்படுத்துவது சில சமயங்களில் அதே செயல்பாட்டை அடையும் போது டாக்ட்ரின் மேல்நிலையைத் தவிர்க்கலாம்.

டாக்ட்ரின் கேச்சிங் மெக்கானிசம் என்பது டேக் அடிப்படையிலான வடிகட்டலை மேம்படுத்துவதற்கான மற்றொரு கருவியாகும். முடிவு தேக்ககத்தை இயக்குவதன் மூலம், ஒரே மாதிரியான நிபந்தனைகளுடன் மீண்டும் மீண்டும் தேடுவது வினவலை மீண்டும் செயல்படுத்துவதைத் தவிர்க்கிறது. தரவு அடிக்கடி மாறாத சூழ்நிலைகளில் இது மிகவும் பயனுள்ளதாக இருக்கும். இந்த உத்திகளை இணைத்தல் -அட்டவணைப்படுத்துதல், வினவல் உகப்பாக்கம் மற்றும் கேச்சிங்-குறிச்சொற்களை வடிகட்டுவதற்கான பல பல வினவல்கள் வேகமாகவும் அளவிடக்கூடியதாகவும் இருப்பதை உறுதி செய்கிறது. இந்த நுட்பங்களை முறையாக செயல்படுத்துவது, பயன்பாடு மற்றும் தரவுத்தளம் வளரும்போது டெவலப்பர்கள் இடையூறுகளைத் தவிர்க்க உதவுகிறது. 🚀