à²à²¨à³ expr()->andX() à²¬à²³à²¸à²¿à²¦ à²µà²¿à²§à²¾à²¨?

ಸಿದ್ಧಾಂತ ORM: ಬಹು

Raphael Thomas

ಶುಕ್ರವಾರ, ಜನವರಿ 3, 2025 10:51:37 ಅಪರಾಹ್ನ

ಡಾಕ್ಟ್ರಿನ್ ORM ಪ್ರಶ್ನೆಗಳಲ್ಲಿ ಟ್ಯಾಗ್-ಆಧಾರಿತ ಫಿಲ್ಟರಿಂಗ್ ಅನ್ನು ಮಾಸ್ಟರಿಂಗ್ ಮಾಡಿ

ಬಹು ಟ್ಯಾಗ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಬಳಕೆದಾರರು ಫಲಿತಾಂಶಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಬಹುದಾದ ಉಲ್ಲೇಖ ಹುಡುಕಾಟ ವೈಶಿಷ್ಟ್ಯವನ್ನು ನೀವು ನಿರ್ಮಿಸುತ್ತಿರುವಿರಿ ಎಂದು ಊಹಿಸಿ. 🏷️ ಮೊದಲಿಗೆ, ಇದು ನೇರವಾಗಿ ತೋರುತ್ತದೆ-ನೀವು ಪ್ರಶ್ನೆಯನ್ನು ಬರೆಯಿರಿ, ಕೋಷ್ಟಕಗಳನ್ನು ಸೇರಿಕೊಳ್ಳಿ ಮತ್ತು ಫಲಿತಾಂಶಗಳನ್ನು ನಿರೀಕ್ಷಿಸಿ. ಆದಾಗ್ಯೂ, ನೀವು ಬಹು ಟ್ಯಾಗ್‌ಗಳನ್ನು ಸೇರಿಸಿದಾಗ, ಪ್ರಶ್ನೆಯು ಖಾಲಿ ಫಲಿತಾಂಶಗಳನ್ನು ಹಿಂದಿರುಗಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಅಥವಾ ಅನಿರೀಕ್ಷಿತವಾಗಿ ವರ್ತಿಸುತ್ತದೆ.

ಹಲವು ಹಲವು ಸಂಬಂಧಗಳು ವ್ಯವಹರಿಸುವಾಗ ಇದು ಡಾಕ್ಟ್ರಿನ್ ORM ನಲ್ಲಿ ಡೆವಲಪರ್‌ಗಳು ಎದುರಿಸುವ ಸಾಮಾನ್ಯ ಸವಾಲಾಗಿದೆ. ಬಹು ಟ್ಯಾಗ್‌ಗಳ ಮೂಲಕ ಫಿಲ್ಟರಿಂಗ್‌ಗೆ ನಿಖರತೆಯ ಅಗತ್ಯವಿರುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಎಲ್ಲಿ ಷರತ್ತುಗಳು ಮತ್ತು AND ಅಥವಾ IN ನಂತಹ ತಾರ್ಕಿಕ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಸಂಯೋಜಿಸುವಾಗ. ಸರಿಯಾದ ವಿಧಾನವಿಲ್ಲದೆ, ನೀವು ಸ್ಥಿರ ಫಲಿತಾಂಶಗಳನ್ನು ಪಡೆಯಲು ಹೆಣಗಾಡಬಹುದು.

ಇತ್ತೀಚಿನ ಯೋಜನೆಯಲ್ಲಿ, ನಾನು ಈ ನಿಖರವಾದ ಸಮಸ್ಯೆಯನ್ನು ಎದುರಿಸಿದೆ. ಬಳಕೆದಾರರು ಕೇವಲ ಒಂದಲ್ಲದೇ ಎಲ್ಲಾ ಆಯ್ದ ಟ್ಯಾಗ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಉಲ್ಲೇಖಗಳನ್ನು ಹುಡುಕುವ ಅಗತ್ಯವಿದೆ. ನಾನು ಮತ್ತು ಷರತ್ತುಗಳು ಮತ್ತು IN() ಷರತ್ತುಗಳನ್ನು ಪ್ರಯತ್ನಿಸಿದೆ, ಆದರೆ ಪ್ರಶ್ನೆ ತರ್ಕವು ಡಾಕ್ಟ್ರಿನ್‌ನ ಪ್ರಶ್ನೆ ಬಿಲ್ಡರ್‌ನೊಂದಿಗೆ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲಿಲ್ಲ. ನಾನು ಪರಿಹಾರವನ್ನು ಕಂಡುಕೊಳ್ಳುವವರೆಗೂ ಅದು ನನ್ನ ತಲೆಯನ್ನು ಕೆರೆದುಕೊಂಡಿತು. 💡

ಈ ಲೇಖನದಲ್ಲಿ, ಡಾಕ್ಟ್ರಿನ್ ORM ಅನ್ನು ಬಳಸಿಕೊಂಡು ಹಲವು ಅನೇಕ ಸಂಬಂಧಗಳಲ್ಲಿ ಪ್ರಶ್ನೆಗಳನ್ನು ಹೇಗೆ ಸಂಕುಚಿತಗೊಳಿಸುವುದು ಎಂಬುದರ ಕುರಿತು ನಾನು ನಿಮಗೆ ತಿಳಿಸುತ್ತೇನೆ. ನೀವು "ಮತ್ತು" ತರ್ಕದೊಂದಿಗೆ ಬಹು ಟ್ಯಾಗ್‌ಗಳ ಮೂಲಕ ಫಿಲ್ಟರ್ ಮಾಡುತ್ತಿದ್ದೀರಾ ಅಥವಾ ಕಸ್ಟಮ್ ಪ್ರಶ್ನೆ ತರ್ಕದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೀರಿ, ಇದನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡಲು ನಾನು ಸ್ಪಷ್ಟವಾದ, ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಉದಾಹರಣೆಯನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತೇನೆ. ಧುಮುಕೋಣ! 🚀

ಆಜ್ಞೆ	ಬಳಕೆಯ ಉದಾಹರಣೆ
createQueryBuilder	ಡಾಕ್ಟ್ರಿನ್ ಪ್ರಶ್ನೆಗಳನ್ನು ರಚಿಸಲು ಮತ್ತು ಕುಶಲತೆಯಿಂದ ಬಳಸಲಾಗುತ್ತದೆ. ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಕೋಡ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಡೈನಾಮಿಕ್ ಪ್ರಶ್ನೆಗಳನ್ನು ನಿರ್ಮಿಸಲು ಇದು ಹೊಂದಿಕೊಳ್ಳುವ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಸೇರಿ ಬಿಟ್ಟೆ	ManyToMany ಸಂಬಂಧದಿಂದ ಡೇಟಾವನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ಅಥವಾ ಪ್ರವೇಶಿಸಲು ಅನುಮತಿಸಲು ಮುಖ್ಯ ಘಟಕಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಕೋಷ್ಟಕವನ್ನು (ಉದಾ., ಟ್ಯಾಗ್‌ಗಳ ಟೇಬಲ್) ಸೇರುತ್ತದೆ.
expr()->expr()->ಮತ್ತುX()	ತಾರ್ಕಿಕ AND ನೊಂದಿಗೆ ಬಹು ಷರತ್ತುಗಳನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ. ಎಲ್ಲಾ ಟ್ಯಾಗ್ ಮಾನದಂಡಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಪೂರೈಸುವ ಫಲಿತಾಂಶಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ಉಪಯುಕ್ತವಾಗಿದೆ.
expr()->expr()->eq()	ಕ್ಷೇತ್ರವು ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯಕ್ಕೆ ಸಮನಾಗಿರಬೇಕು ಎಂದು ಸೂಚಿಸುತ್ತದೆ. ನಿರ್ದಿಷ್ಟ ಟ್ಯಾಗ್ ಐಡಿಗಳನ್ನು ಹೊಂದಿಸಲು ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.
ಸೆಟ್ ಪ್ಯಾರಾಮೀಟರ್	ಕ್ವೆರಿ ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್‌ಗೆ ಮೌಲ್ಯವನ್ನು ಬಂಧಿಸುತ್ತದೆ, ಡೇಟಾ ಸುರಕ್ಷತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ ಮತ್ತು SQL ಇಂಜೆಕ್ಷನ್ ಅಪಾಯಗಳನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.
ಮತ್ತು ಎಲ್ಲಿ	ಪ್ರಶ್ನೆಗೆ ಷರತ್ತುಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಸೇರಿಸುತ್ತದೆ, ಅವುಗಳನ್ನು ಮತ್ತು ತರ್ಕದೊಂದಿಗೆ ಸಂಯೋಜಿಸುತ್ತದೆ.
ಮೊದಲ ಫಲಿತಾಂಶವನ್ನು ಹೊಂದಿಸಿ	ವಿನ್ಯಾಸಕ್ಕಾಗಿ ಆಫ್‌ಸೆಟ್ ಅನ್ನು ಹೊಂದಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ, ಫಲಿತಾಂಶಗಳನ್ನು ಒಂದೇ ಬಾರಿಗೆ ಪ್ರದರ್ಶಿಸುವ ಬದಲು ಭಾಗಗಳಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.
setMaxResults	ಹಿಂಪಡೆಯಲು ಗರಿಷ್ಠ ಸಂಖ್ಯೆಯ ಫಲಿತಾಂಶಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ, ಇದು ಪ್ರಶ್ನೆ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಅತ್ಯುತ್ತಮವಾಗಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಗುಂಪು ... COUNT ಹೊಂದಿರುವವರು	ಗ್ರೂಪಿಂಗ್ ಫಲಿತಾಂಶಗಳು ಮತ್ತು ಟ್ಯಾಗ್ ಎಣಿಕೆ ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸುವ ಗುಂಪುಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವ ಮೂಲಕ ಫಲಿತಾಂಶಗಳು ಎಲ್ಲಾ ಆಯ್ಕೆಮಾಡಿದ ಟ್ಯಾಗ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
ತರಲು()	API ವಿನಂತಿಯ ಮೂಲಕ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಬ್ಯಾಕೆಂಡ್‌ಗೆ ಡೇಟಾವನ್ನು (ಆಯ್ಕೆ ಮಾಡಿದ ಟ್ಯಾಗ್‌ಗಳು) ಕಳುಹಿಸಲು ಮುಂಭಾಗದ ತುದಿಯಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಟ್ಯಾಗ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಡಾಕ್ಟ್ರಿನ್ ORM ನಲ್ಲಿ ಉಲ್ಲೇಖಗಳನ್ನು ಹೇಗೆ ಫಿಲ್ಟರ್ ಮಾಡುವುದು

ಬ್ಯಾಕೆಂಡ್‌ನಲ್ಲಿ, ಮೂಲಕ ಉಲ್ಲೇಖಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲಾಗುತ್ತಿದೆ ಬಹು ಟ್ಯಾಗ್‌ಗಳು ManyToMany ಸಂಬಂಧಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಎಚ್ಚರಿಕೆಯಿಂದ ಪ್ರಶ್ನೆಯನ್ನು ನಿರ್ಮಿಸುವ ಅಗತ್ಯವಿದೆ. `createQueryBuilder` ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ರಚಿಸಲಾದ ಪ್ರಶ್ನೆ ಬಿಲ್ಡರ್‌ನೊಂದಿಗೆ ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ಇಲ್ಲಿ ಮೂಲ ಘಟಕವನ್ನು (`quote`) ಆಯ್ಕೆ ಮಾಡಲಾಗುತ್ತದೆ. ಟ್ಯಾಗ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ಉಲ್ಲೇಖಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು, `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 ಸಂಬಂಧಿತ ಟ್ಯಾಗ್‌ಗೆ ಹೊಂದಿಕೆಯಾಗಬೇಕು. ಎಲ್ಲಾ ನಿಗದಿತ ಟ್ಯಾಗ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಉಲ್ಲೇಖಗಳನ್ನು ಮಾತ್ರ ಹಿಂತಿರುಗಿಸಲಾಗಿದೆ ಎಂದು ಪ್ರಶ್ನೆ ಖಚಿತಪಡಿಸುತ್ತದೆ. ಈ ವಿಧಾನವು ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ, ಅಲ್ಲಿ ಅನೇಕ ಟ್ಯಾಗ್‌ಗಳ ಮೂಲಕ ಫಿಲ್ಟರಿಂಗ್ ಅಸಮರ್ಪಕ ಪ್ರಶ್ನೆ ನಿರ್ಮಾಣದ ಕಾರಣದಿಂದಾಗಿ ಯಾವುದೇ ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡುವುದಿಲ್ಲ.

ಮುಂಭಾಗದ ತುದಿಯಲ್ಲಿ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪಡೆಯುವ ಕಾರ್ಯವು ಬಳಕೆದಾರರ ಆಯ್ಕೆ ಟ್ಯಾಗ್‌ಗಳನ್ನು ಬ್ಯಾಕೆಂಡ್‌ಗೆ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಕಳುಹಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರರು 88 ಮತ್ತು 306 ಟ್ಯಾಗ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಿದರೆ, ಈ ಐಡಿಗಳನ್ನು JSON ವಿನಂತಿಯಲ್ಲಿ ಸೇರಿಸಲಾಗುತ್ತದೆ. ಬ್ಯಾಕೆಂಡ್ ಈ ವಿನಂತಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ, ಸೂಕ್ತವಾದ ಷರತ್ತುಗಳೊಂದಿಗೆ ಪ್ರಶ್ನೆಯನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ ಮತ್ತು ಫಿಲ್ಟರ್ ಮಾಡಿದ ಫಲಿತಾಂಶಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಈ ದ್ವಿಮುಖ ಸಂವಹನವು ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್‌ನ ಆಧಾರದ ಮೇಲೆ ಹುಡುಕಾಟವು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ನವೀಕರಣಗೊಳ್ಳುವ ಸುಗಮ ಬಳಕೆದಾರ ಅನುಭವವನ್ನು ಖಾತ್ರಿಗೊಳಿಸುತ್ತದೆ. 🚀

ಸುಧಾರಿತ ಪ್ರಶ್ನೆ ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ, ಟ್ಯಾಗ್‌ಗಳು ಸರಿಯಾಗಿ ಹೊಂದಾಣಿಕೆಯಾಗುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು `GROUP BY` ಮತ್ತು `HAVING COUNT` ನಂತಹ SQL ಆಜ್ಞೆಗಳನ್ನು ನೇರವಾಗಿ ಬಳಸಬಹುದು. ಉಲ್ಲೇಖಗಳನ್ನು ಗುಂಪು ಮಾಡುವ ಮೂಲಕ ಮತ್ತು ಅವುಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ವಿಭಿನ್ನ ಟ್ಯಾಗ್‌ಗಳನ್ನು ಎಣಿಸುವ ಮೂಲಕ, ಪ್ರಶ್ನೆಯು ಟ್ಯಾಗ್ ಎಣಿಕೆ ಮಾನದಂಡಗಳನ್ನು ಪೂರೈಸದ ಯಾವುದೇ ಉಲ್ಲೇಖಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, `setFirstResult` ಮತ್ತು `setMaxResults` ಬಳಕೆಯು ಸರಿಯಾದ ಪೇಜಿನೇಶನ್ ಖಾತ್ರಿಗೊಳಿಸುತ್ತದೆ, ಇದು ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ. ಉಲ್ಲೇಖಗಳ ದೊಡ್ಡ ಪೂಲ್ ನಡುವೆ ನಿರ್ದಿಷ್ಟ, ಫಿಲ್ಟರ್ ಮಾಡಿದ ಫಲಿತಾಂಶಗಳಿಗಾಗಿ ಬಳಕೆದಾರರು ಹುಡುಕುವ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಈ ವಿಧಾನವು ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. 😊

ಸಿದ್ಧಾಂತ ORM: ಬಹು ಟ್ಯಾಗ್‌ಗಳೊಂದಿಗೆ ಹಲವು ಸಂಬಂಧಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದು

PHP ಮತ್ತು ಡಾಕ್ಟ್ರಿನ್ ORM ಅನ್ನು ಬಳಸಿಕೊಂಡು ಬ್ಯಾಕೆಂಡ್ ಅನುಷ್ಠಾನ

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

ಬಹು ಟ್ಯಾಗ್‌ಗಳೊಂದಿಗೆ ಉಲ್ಲೇಖಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ಸುಧಾರಿತ SQL ಪ್ರಶ್ನೆ

ಆಪ್ಟಿಮೈಸ್ಡ್ ಡೇಟಾಬೇಸ್ ಫಿಲ್ಟರಿಂಗ್‌ಗಾಗಿ ರಾ SQL ಪ್ರಶ್ನೆ

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));

PHPUnit ನಲ್ಲಿ ಡಾಕ್ಟ್ರಿನ್ ಪ್ರಶ್ನೆಗಾಗಿ ಘಟಕ ಪರೀಕ್ಷೆ

ಪ್ರಶ್ನೆ ತರ್ಕವನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು PHPUnit ಪರೀಕ್ಷೆ

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()->ಮತ್ತೊಂದು ನಿರ್ಣಾಯಕ ಆಪ್ಟಿಮೈಸೇಶನ್ ಅನಗತ್ಯ ಸೇರ್ಪಡೆಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಎಲ್ಲಾ ಆಯ್ದ ಟ್ಯಾಗ್‌ಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗುವ ಉಲ್ಲೇಖ ID ಗಳು ಮಾತ್ರ ನಿಮಗೆ ಅಗತ್ಯವಿದ್ದಾಗ, ನೀವು `GROUP BY` ಮತ್ತು `HAVING COUNT` ಅನ್ನು ಬಳಸಿಕೊಂಡು ಒಂದೇ ಪ್ರಶ್ನೆಯೊಂದಿಗೆ ID ಗಳನ್ನು ಹಿಂಪಡೆಯಬಹುದು. ಇದು ಸಂಪೂರ್ಣ ಸಾಲುಗಳನ್ನು ಪಡೆಯುವುದನ್ನು ತಪ್ಪಿಸುತ್ತದೆ ಮತ್ತು ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಪ್ರಶ್ನೆ ಬಿಲ್ಡರ್‌ನ `expr()->andX()` ವಿಧಾನವನ್ನು ದೊಡ್ಡ ಪ್ರಮಾಣದ ಫಿಲ್ಟರಿಂಗ್‌ಗಾಗಿ ಆಪ್ಟಿಮೈಸ್ ಮಾಡಿದ ಕಚ್ಚಾ SQL ನೊಂದಿಗೆ ಬದಲಾಯಿಸಬಹುದು. ಕಚ್ಚಾ SQL ಅನ್ನು ಬಳಸುವುದು ಕೆಲವೊಮ್ಮೆ ಅದೇ ಕಾರ್ಯವನ್ನು ಸಾಧಿಸುವಾಗ ಡಾಕ್ಟ್ರಿನ್ ಓವರ್ಹೆಡ್ ಅನ್ನು ಬೈಪಾಸ್ ಮಾಡಬಹುದು.

ಟ್ಯಾಗ್-ಆಧಾರಿತ ಫಿಲ್ಟರಿಂಗ್ ಅನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಲು ಡಾಕ್ಟ್ರಿನ್‌ನ ಕ್ಯಾಶಿಂಗ್ ಮೆಕ್ಯಾನಿಸಂ ಮತ್ತೊಂದು ಸಾಧನವಾಗಿದೆ. ಫಲಿತಾಂಶದ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವಿಕೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವ ಮೂಲಕ, ಒಂದೇ ರೀತಿಯ ಪರಿಸ್ಥಿತಿಗಳೊಂದಿಗೆ ಪುನರಾವರ್ತಿತ ಹುಡುಕಾಟಗಳು ಪ್ರಶ್ನೆಯನ್ನು ಮರು-ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ತಪ್ಪಿಸುತ್ತವೆ. ಡೇಟಾ ಆಗಾಗ್ಗೆ ಬದಲಾಗದ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ. ಈ ತಂತ್ರಗಳನ್ನು ಸಂಯೋಜಿಸುವುದು -ಇಂಡೆಕ್ಸಿಂಗ್, ಕ್ವೆರಿ ಆಪ್ಟಿಮೈಸೇಶನ್, ಮತ್ತು ಕ್ಯಾಶಿಂಗ್-ಟ್ಯಾಗ್‌ಗಳನ್ನು ಫಿಲ್ಟರಿಂಗ್ ಮಾಡಲು ಹಲವು ಪ್ರಶ್ನೆಗಳು ವೇಗವಾಗಿ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಆಗಿ ಉಳಿಯುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಈ ತಂತ್ರಗಳ ಸರಿಯಾದ ಅನುಷ್ಠಾನವು ಅಪ್ಲಿಕೇಶನ್ ಮತ್ತು ಡೇಟಾಬೇಸ್ ಬೆಳೆದಂತೆ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅಡಚಣೆಗಳನ್ನು ತಪ್ಪಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. 🚀

ಡಾಕ್ಟ್ರಿನ್ ORM ಟ್ಯಾಗ್ ಪ್ರಶ್ನೆಗಳ ಬಗ್ಗೆ ಪದೇ ಪದೇ ಕೇಳಲಾಗುವ ಪ್ರಶ್ನೆಗಳು

ಏನು expr()->andX() ಬಳಸಿದ ವಿಧಾನ?
ದಿ expr()->andX() ಡಾಕ್ಟ್ರಿನ್ ಕ್ವೆರಿ ಬಿಲ್ಡರ್‌ನಲ್ಲಿ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಮತ್ತು ತರ್ಕದೊಂದಿಗೆ ಬಹು ಷರತ್ತುಗಳನ್ನು ಸಂಯೋಜಿಸಲು ವಿಧಾನವು ಅನುಮತಿಸುತ್ತದೆ.
ಡಾಕ್ಟ್ರಿನ್‌ನೊಂದಿಗೆ ಹಲವು ಪ್ರಶ್ನೆಗಳನ್ನು ನಾನು ಹೇಗೆ ಆಪ್ಟಿಮೈಜ್ ಮಾಡಬಹುದು?
ಬಳಸಿ GROUP BY ಮತ್ತು HAVING COUNT ಬಹು-ಟ್ಯಾಗ್ ಫಿಲ್ಟರಿಂಗ್‌ಗಾಗಿ, ಡೇಟಾಬೇಸ್ ಇಂಡೆಕ್ಸಿಂಗ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ ಮತ್ತು ಪುನರಾವರ್ತಿತ ಪ್ರಶ್ನೆಗಳಿಗಾಗಿ ಡಾಕ್ಟ್ರಿನ್ ಕ್ಯಾಶಿಂಗ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ.
ಬಹು ಟ್ಯಾಗ್‌ಗಳ ಮೂಲಕ ಫಿಲ್ಟರ್ ಮಾಡುವಾಗ ನನ್ನ ಪ್ರಶ್ನೆಯು ಯಾವುದೇ ಫಲಿತಾಂಶಗಳನ್ನು ಏಕೆ ನೀಡುವುದಿಲ್ಲ?
ಇದು ಸಂಭವಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಮತ್ತು ತರ್ಕದೊಂದಿಗೆ ಟ್ಯಾಗ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸಲು ಪ್ರತಿ ದಾಖಲೆಯು ಎಲ್ಲಾ ಟ್ಯಾಗ್‌ಗಳನ್ನು ಹೊಂದಿಸುವ ಅಗತ್ಯವಿದೆ. ಬಳಸಿ expr()->andX() ಕಚ್ಚಾ SQL ನೊಂದಿಗೆ ಸರಿಯಾಗಿ ಅಥವಾ ಆಪ್ಟಿಮೈಜ್ ಮಾಡಿ.
ನನ್ನ ಡಾಕ್ಟ್ರಿನ್ ಪ್ರಶ್ನೆಗಳಿಗೆ ನಾನು ಪುಟವಿನ್ಯಾಸವನ್ನು ಹೇಗೆ ಸೇರಿಸಬಹುದು?
ಬಳಸಿ setFirstResult() ಮತ್ತು setMaxResults() ಫಲಿತಾಂಶದ ಆಫ್‌ಸೆಟ್ ಮತ್ತು ಮಿತಿಯನ್ನು ನಿಯಂತ್ರಿಸಲು ನಿಮ್ಮ ಪ್ರಶ್ನೆ ಬಿಲ್ಡರ್‌ನಲ್ಲಿರುವ ವಿಧಾನಗಳು.
ಡಾಕ್ಟ್ರಿನ್ ಪ್ರಶ್ನೆಗಳನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವುದರ ಪ್ರಯೋಜನವೇನು?
ಬಳಸಿಕೊಂಡು ಫಲಿತಾಂಶಗಳನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವ ಮೂಲಕ Doctrine Cache, ನೀವು ದುಬಾರಿ ಪ್ರಶ್ನೆಗಳನ್ನು ಮರು-ಚಾಲನೆ ಮಾಡುವುದನ್ನು ತಪ್ಪಿಸುತ್ತೀರಿ, ಪುನರಾವರ್ತಿತ ಹುಡುಕಾಟಗಳಿಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತೀರಿ.
ನಾನು ಡಾಕ್ಟ್ರಿನ್ ORM ನಲ್ಲಿ ಸಂಬಂಧಿತ ಘಟಕಗಳನ್ನು ಹೇಗೆ ಸೇರುವುದು?
ಬಳಸಿ leftJoin() ಅಥವಾ innerJoin() ಸಂಬಂಧಿತ ಕೋಷ್ಟಕಗಳನ್ನು ಸಂಪರ್ಕಿಸಲು ಮತ್ತು ಫಿಲ್ಟರಿಂಗ್ಗಾಗಿ ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸಲು ವಿಧಾನಗಳು.
ಪ್ರಶ್ನೆ ಬಿಲ್ಡರ್ ಬದಲಿಗೆ ಡಾಕ್ಟ್ರಿನ್‌ನಲ್ಲಿ ಕಚ್ಚಾ SQL ಅನ್ನು ಬಳಸಬಹುದೇ?
ಹೌದು, ಡಾಕ್ಟ್ರಿನ್ ಇದರೊಂದಿಗೆ ಕಚ್ಚಾ SQL ಅನ್ನು ಅನುಮತಿಸುತ್ತದೆ createNativeQuery(). ಕ್ವೆರಿ ಬಿಲ್ಡರ್ ಆಪ್ಟಿಮೈಸ್ ಮಾಡಲು ಕಷ್ಟಪಡುವ ಸಂಕೀರ್ಣ ಪ್ರಶ್ನೆಗಳಿಗೆ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.
ಬಳಕೆದಾರರಿಂದ ಟ್ಯಾಗ್ ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ನಾನು ಹೇಗೆ ಮೌಲ್ಯೀಕರಿಸಬಹುದು?
ಬಳಕೆದಾರ ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ಸ್ಯಾನಿಟೈಜ್ ಮಾಡಿ ಮತ್ತು ಬಳಸಿ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಬೈಂಡ್ ಮಾಡಿ setParameter() SQL ಇಂಜೆಕ್ಷನ್ ಅನ್ನು ತಡೆಗಟ್ಟಲು ಮತ್ತು ಡೇಟಾ ಸುರಕ್ಷತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು.
ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು AND ಮತ್ತು IN() ಟ್ಯಾಗ್ ಫಿಲ್ಟರಿಂಗ್‌ನಲ್ಲಿ?
ಬಳಸುತ್ತಿದೆ IN() ಯಾವುದೇ ಟ್ಯಾಗ್‌ಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗುವ ದಾಖಲೆಗಳನ್ನು ಪಡೆಯುತ್ತದೆ AND ತರ್ಕವು ಎಲ್ಲಾ ಟ್ಯಾಗ್‌ಗಳು ದಾಖಲೆಯಲ್ಲಿ ಇರಬೇಕೆಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
ನಿಧಾನವಾದ ಡಾಕ್ಟ್ರಿನ್ ಪ್ರಶ್ನೆಗಳನ್ನು ನಾನು ಹೇಗೆ ನಿವಾರಿಸಬಹುದು?
ಮುಂತಾದ ಪರಿಕರಗಳನ್ನು ಬಳಸಿ EXPLAIN SQL ನಲ್ಲಿ ಪ್ರಶ್ನೆಯ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ವಿಶ್ಲೇಷಿಸಲು ಮತ್ತು ಕಾಣೆಯಾದ ಸೂಚ್ಯಂಕಗಳು ಅಥವಾ ಅಸಮರ್ಥ ಸೇರ್ಪಡೆಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು.
ಕಚ್ಚಾ SQL ಅಥವಾ ಡಾಕ್ಟ್ರಿನ್ ಕ್ವೆರಿ ಬಿಲ್ಡರ್ ಅನ್ನು ಬಳಸುವುದು ಉತ್ತಮವೇ?
ಸರಳ ಪ್ರಶ್ನೆಗಳಿಗೆ, ದಿ query builder ಸಾಕಾಗುತ್ತದೆ, ಆದರೆ ಸಂಕೀರ್ಣ ಫಿಲ್ಟರಿಂಗ್‌ಗಾಗಿ, ಕಚ್ಚಾ SQL ಅನ್ನು ಹೆಚ್ಚು ಆಪ್ಟಿಮೈಸ್ ಮಾಡಬಹುದು ಮತ್ತು ಪರಿಣಾಮಕಾರಿಯಾಗಿರಬಹುದು.

ಡಾಕ್ಟ್ರಿನ್ ORM ನಲ್ಲಿ ಪ್ರಶ್ನೆ ದಕ್ಷತೆಯನ್ನು ಪರಿಷ್ಕರಿಸುವುದು

a ನಲ್ಲಿ ಬಹು ಟ್ಯಾಗ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಉಲ್ಲೇಖಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲಾಗುತ್ತಿದೆ ಹಲವು ಸಂಬಂಧಗಳು ಎಚ್ಚರಿಕೆಯಿಂದ ಪ್ರಶ್ನೆ ನಿರ್ಮಾಣದ ಅಗತ್ಯವಿದೆ. ತಾರ್ಕಿಕ ಮತ್ತು ಷರತ್ತುಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ, ಡೇಟಾಬೇಸ್ ಅನ್ನು ಸೂಚಿಕೆ ಮಾಡುವ ಮೂಲಕ ಮತ್ತು ವಿನ್ಯಾಸ ವಿಧಾನಗಳನ್ನು ನಿಯಂತ್ರಿಸುವ ಮೂಲಕ, ಕಾರ್ಯಕ್ಷಮತೆಗೆ ಧಕ್ಕೆಯಾಗದಂತೆ ನಿಖರ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಫಲಿತಾಂಶಗಳನ್ನು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುತ್ತೀರಿ.

ಖಾಲಿ ಫಲಿತಾಂಶಗಳನ್ನು ಹಿಂತಿರುಗಿಸುವಂತಹ ಸವಾಲುಗಳನ್ನು ಎದುರಿಸಿದಾಗ, ತಂತ್ರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರಶ್ನೆಗಳನ್ನು ಉತ್ತಮಗೊಳಿಸುವುದು expr()->expr()->ಮತ್ತುX() ಅಥವಾ ಕಚ್ಚಾ SQL ಗೆ ಬದಲಾಯಿಸುವುದರಿಂದ ವ್ಯತ್ಯಾಸವನ್ನು ಮಾಡಬಹುದು. ಸಂಕೀರ್ಣವಾದ ಪ್ರಶ್ನೆ ತರ್ಕವನ್ನು ಸರಳೀಕರಿಸುವಾಗ ಈ ಪರಿಹಾರಗಳು ಸ್ಕೇಲೆಬಿಲಿಟಿ ಮತ್ತು ಬಳಕೆದಾರರ ತೃಪ್ತಿಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತವೆ. ಹ್ಯಾಪಿ ಕೋಡಿಂಗ್! 😊

ಮೂಲಗಳು ಮತ್ತು ಉಲ್ಲೇಖಗಳು

ಡಾಕ್ಟ್ರಿನ್ ORM ನೊಂದಿಗೆ ಹಲವು ಸಂಬಂಧಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ಪರಿಹಾರಗಳನ್ನು ವಿವರಿಸುತ್ತದೆ. ಸಂಬಂಧಿತ ಚರ್ಚೆಗಳು ಮತ್ತು ಪರಿಹಾರಗಳನ್ನು ಹುಡುಕಿ ಸ್ಟಾಕ್ ಓವರ್‌ಫ್ಲೋ .
ಡಾಕ್ಟ್ರಿನ್ ಕ್ವೆರಿಬಿಲ್ಡರ್ ವಿಧಾನಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಉಲ್ಲೇಖ expr()->expr()->ಮತ್ತುX() ಮತ್ತು ಸುಧಾರಿತ SQL ಸೇರುತ್ತದೆ: ಡಾಕ್ಟ್ರಿನ್ ORM ಡಾಕ್ಯುಮೆಂಟೇಶನ್ .
ಡೇಟಾಬೇಸ್ ಪ್ರಶ್ನೆಗಳಲ್ಲಿ ವಿವರಿಸಲಾದ ಟ್ಯಾಗ್‌ಗಳೊಂದಿಗೆ ಫಿಲ್ಟರಿಂಗ್‌ನ ನೈಜ-ಪ್ರಪಂಚದ ಬಳಕೆಯ ಪ್ರಕರಣ: Baeldung JPA ಮಾರ್ಗದರ್ಶಿ .

ಸಿದ್ಧಾಂತ ORM: ಬಹು ಟ್ಯಾಗ್‌ಗಳೊಂದಿಗೆ ಹಲವು ಪ್ರಶ್ನೆಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದು