परिचय
डेटाबेस में डेटा के साथ काम करने के लिए, आपको विशिष्ट रिकॉर्ड को प्रभावी ढंग से पुनर्प्राप्त करने और लक्षित करने में सक्षम होना चाहिए। अपने प्रश्नों में फ़िल्टरिंग क्लॉज़ का उपयोग करके, आप केवल सबसे प्रासंगिक रिकॉर्ड वापस करने के लिए विशिष्ट मानदंड जोड़ सकते हैं।
इस गाइड में, हम पोस्टग्रेएसक्यूएल के भीतर उपलब्ध कुछ सबसे सामान्य फ़िल्टरिंग कार्यों पर एक नज़र डालेंगे और प्रदर्शित करेंगे कि आपके बयानों के फोकस को कम करने के लिए उनका उपयोग कैसे किया जाए। हम WHERE . के साथ अलग-अलग रिकॉर्ड में विशेषताओं के विरुद्ध परीक्षण करने का तरीका दिखाएंगे खंड, GROUP BY . के साथ जानकारी को सारांशित करने के लिए रिकॉर्ड को एक साथ कैसे समूहित करें? , रिकॉर्ड के समूहों को HAVING . के साथ कैसे फ़िल्टर करें उपखंड, और LIMIT . के साथ लौटाई गई पंक्तियों की अधिकतम संख्या कैसे सेट करें खंड।
WHERE का उपयोग करना मैच मानदंड परिभाषित करने के लिए खंड
अपनी क्वेरी आवश्यकताओं को इंगित करने के लिए सबसे आम और व्यापक रूप से उपयोगी तरीकों में से एक है WHERE खंड। WHERE क्लॉज आपको उन शर्तों को निर्दिष्ट करके क्वेरी स्टेटमेंट के लिए वास्तविक खोज मानदंड परिभाषित करने देता है जो सभी मिलान रिकॉर्ड के लिए सही होनी चाहिए।
WHERE क्लॉज बूलियन एक्सप्रेशंस को परिभाषित करके काम करते हैं जो डेटा की प्रत्येक उम्मीदवार पंक्ति के खिलाफ चेक किए जाते हैं। यदि अभिव्यक्ति का परिणाम गलत है, तो परिणाम से पंक्ति हटा दी जाएगी और वापस नहीं की जाएगी या प्रसंस्करण के अगले चरण में जारी रहेगी। यदि अभिव्यक्ति का परिणाम सत्य है, तो यह खोज के मानदंडों को पूरा करता है और उम्मीदवार पंक्ति के रूप में आगे की प्रक्रिया के लिए जारी रहेगा।
WHERE . का मूल सिंटैक्स क्लॉज इस तरह दिखता है:
SELECT * FROM my_table WHERE <condition>;
<condition> कुछ भी हो सकता है जिसके परिणामस्वरूप बूलियन मान हो। PostgreSQL में, एक बूलियन मान TRUE . में से कोई भी होता है , FALSE , या NULL ।
निम्नलिखित में से एक या अधिक ऑपरेटरों का उपयोग करके अक्सर स्थितियां बनाई जाती हैं:
=:के बराबर>:इससे बड़ा<:से कम>=:इससे बड़ा या इसके बराबर<=:इससे कम या इसके बराबर<>या!=:बराबर नहींAND:तार्किक "और" ऑपरेटर — दो शर्तों को जोड़ता है औरTRUE. देता है यदि दोनों शर्तेंTRUEहैंOR:तार्किक "या" ऑपरेटर - दो शर्तों को जोड़ता है औरTRUE. देता है यदि कम से कम एक शर्तTRUEहैIN:मूल्य सूची, श्रृंखला या श्रेणी में निहित है जो इस प्रकार हैBETWEEN:मूल्य सीमा के भीतर समाहित है न्यूनतम और अधिकतम मान जो अनुसरण करते हैं, समावेशीIS NULL:मैच अगर मानNULLहैNOT:निम्नलिखित बूलियन मान को नकारता हैEXISTS:निम्नलिखित क्वेरी में परिणाम शामिल हैंLIKE:एक पैटर्न के साथ मेल खाता है (वाइल्डकार्ड का उपयोग करके%0 या अधिक वर्णों का मिलान करने के लिए और_एक वर्ण से मेल खाने के लिए)ILIKE:एक पैटर्न के साथ मेल खाता है (वाइल्डकार्ड का उपयोग करके%0 या अधिक वर्णों का मिलान करने के लिए और_एकल वर्ण से मेल खाने के लिए), केस असंवेदनशीलSIMILAR TO:SQL की रेगुलर एक्सप्रेशन बोली का उपयोग करते हुए एक पैटर्न से मेल खाता है~:पॉज़िक्स रेगुलर एक्सप्रेशन, केस सेंसिटिव का उपयोग करते हुए एक पैटर्न से मेल खाता है~*:पॉज़िक्स रेगुलर एक्सप्रेशन, केस असंवेदनशील का उपयोग करते हुए एक पैटर्न के विरुद्ध मेल खाता है!~:पॉज़िक्स रेगुलर एक्सप्रेशन, केस सेंसिटिव का उपयोग करने वाले पैटर्न से मेल नहीं खाता!~*:पॉज़िक्स रेगुलर एक्सप्रेशन का उपयोग करने वाले पैटर्न से मेल नहीं खाता, केस असंवेदनशील
जबकि उपरोक्त सूची कुछ सबसे सामान्य परीक्षण संरचनाओं का प्रतिनिधित्व करती है, ऐसे कई अन्य ऑपरेटर हैं जो बूलियन परिणाम उत्पन्न करते हैं जिनका उपयोग WHERE के संयोजन में किया जा सकता है। खंड।
WHERE का उपयोग करने वाले उदाहरण
= . का उपयोग करते हुए समानता के लिए सबसे आम और सीधी जांचों में से एक है ऑपरेटर। यहां, हम जांचते हैं कि customer . में प्रत्येक पंक्ति है या नहीं तालिका में एक last_name है Smith . के बराबर मान :
SELECT * FROM customer WHERE last_name = 'Smith';
तार्किक ऑपरेटरों का उपयोग करके यौगिक अभिव्यक्ति बनाने के लिए हम इसमें अतिरिक्त शर्तें जोड़ सकते हैं। यह उदाहरण AND . का उपयोग करता है first_name . के विरुद्ध एक अतिरिक्त परीक्षण जोड़ने के लिए क्लॉज कॉलम। मान्य पंक्तियों को दी गई दोनों शर्तों को पूरा करना चाहिए:
SELECT * FROM customer WHERE first_name = 'John' AND last_name = 'Smith';
इसी तरह, हम जांच सकते हैं कि क्या शर्तों की कोई श्रृंखला पूरी होती है। यहां, हम address . से पंक्तियों की जांच करते हैं तालिका यह देखने के लिए कि क्या zip_code मान 60626 या neighborhood . के बराबर है कॉलम "रोजर्स पार्क" स्ट्रिंग के बराबर है। हम दो एकल उद्धरण चिह्नों का उपयोग यह इंगित करने के लिए करते हैं कि एक शाब्दिक एकल उद्धरण की खोज की जानी चाहिए:
SELECT * FROM address WHERE zip_code = '60626' OR neighborhood = 'Roger''s Park';
IN ऑपरेटर कोष्ठक में लिपटे कई मानों के बीच तुलना की तरह काम कर सकता है। यदि दिए गए मानों में से किसी के साथ कोई मेल है, तो व्यंजक TRUE . है :
SELECT * FROM customer WHERE last_name IN ('Smith', 'Johnson', 'Fredrich');
यहां, हम LIKE . का उपयोग करके एक स्ट्रिंग पैटर्न के विरुद्ध जांच करते हैं . % शून्य या अधिक वर्णों से मेल खाने वाले वाइल्डकार्ड के रूप में काम करता है, इसलिए "पीट", "पीटर", और "पीट" से शुरू होने वाली कोई अन्य स्ट्रिंग मेल खाएगी:
SELECT * FROM customer WHERE last_name LIKE 'Pete%';
हम ~* . का उपयोग करके ऐसी ही खोज कर सकते हैं मामले की परवाह किए बिना POSIX रेगुलर एक्सप्रेशन का उपयोग करके मैचों की जांच करने के लिए ऑपरेटर। इस मामले में, हम जांचते हैं कि क्या last_name . का मान है एक "डी" से शुरू होता है और इसमें "ऑन" विकल्प होता है, जो "डिकसन", "डोनाल्ड" और "डेवोन" जैसे नामों से मेल खाएगा:
SELECT * FROM customer WHERE last_name ~* '^D.*on.*';
हम BETWEEN . का उपयोग करके जांच सकते हैं कि कोई स्ट्रीट नंबर पतों के 4000 ब्लॉक के भीतर है या नहीं और AND एक समावेशी श्रेणी परिभाषित करने के लिए ऑपरेटर:
SELECT * FROM address WHERE street_number BETWEEN 4000 AND 4999;
यहां, हम किसी भी customer को प्रदर्शित कर सकते हैं ऐसी प्रविष्टियाँ जिनमें सामाजिक सुरक्षा संख्याएँ हैं जो 9 अंकों की लंबी नहीं हैं। हम LENGTH() . का उपयोग करते हैं क्षेत्र में अंकों की संख्या प्राप्त करने के लिए ऑपरेटर और <> असमानता की जांच करने के लिए:
SELECT * FROM customer WHERE LENGTH(SSN) <> 9;
GROUP BY का उपयोग करना एकाधिक अभिलेखों को सारांशित करने के लिए खंड
GROUP BY क्लॉज एक ही पंक्ति के साथ कई परिणामों का प्रतिनिधित्व करके परिणामों को फ़िल्टर करने का एक और बहुत ही सामान्य तरीका है। GROUP BY . का मूल सिंटैक्स क्लॉज इस तरह दिखता है:
SELECT <columns> FROM some_table GROUP BY <columns_to_group>
जब एक GROUP BY क्लॉज को एक स्टेटमेंट में जोड़ा जाता है, यह पोस्टग्रेएसक्यूएल को दिए गए कॉलम या कॉलम के लिए प्रत्येक अद्वितीय मान के लिए एक पंक्ति प्रदर्शित करने के लिए कहता है। इसके कुछ महत्वपूर्ण निहितार्थ हैं।
चूंकि GROUP BY क्लॉज एक पंक्ति के रूप में कई पंक्तियों का प्रतिनिधित्व करने का एक तरीका है, PostgreSQL केवल क्वेरी को निष्पादित कर सकता है यदि वह प्रत्येक कॉलम के लिए एक मान की गणना कर सकता है जिसे इसे प्रदर्शित करने का काम सौंपा गया है। इसका मतलब है कि प्रत्येक कॉलम की पहचान SELECT . द्वारा की गई है कथन का भाग या तो होना चाहिए:
GROUP BYमें शामिल है यह गारंटी देने के लिए कि प्रत्येक पंक्ति का एक अद्वितीय मान है- प्रत्येक समूह में सभी पंक्तियों को सारांशित करने के लिए सार
व्यावहारिक रूप से, इसका मतलब है कि SELECT . में कोई भी कॉलम सूची GROUP BY में शामिल नहीं है क्लॉज को प्रत्येक समूह के लिए कॉलम के लिए एकल परिणाम उत्पन्न करने के लिए एक समग्र फ़ंक्शन का उपयोग करना चाहिए।
GROUP BY का उपयोग करने वाले उदाहरण
इस खंड के उदाहरणों के लिए, मान लीजिए कि हमारे पास pet . नामक एक तालिका है जिसे हमने इस तरह परिभाषित और आबाद किया है:
CREATE TABLE pet ( id SERIAL PRIMARY KEY, type TEXT, name TEXT, color TEXT, age INT);INSERT INTO pet (type, name, color, age) VALUES('dog', 'Spot', 'brown', 3),('dog', 'Rover', 'black', 7),('dog', 'Sally', 'brown', 1),('cat', 'Sabrina', 'black', 8),('cat', 'Felix', 'white', 4),('cat', 'Simon', 'orange', 8),('rabbit', 'Buttons', 'grey', 4),('rabbit', 'Bunny', 'brown', 8),('rabbit', 'Briony', 'brown', 6);
GROUP BY . का सरलतम उपयोग एकल कॉलम के लिए अद्वितीय मानों की श्रेणी प्रदर्शित करना है। ऐसा करने के लिए, SELECT . में उसी कॉलम का इस्तेमाल करें और GROUP BY . यहाँ, हम तालिका में उपयोग किए गए सभी रंग देखते हैं:
SELECT color FROM pet GROUP BY color;
color-------- black grey brown white orange(5 rows)
जैसे ही आप SELECT . में एक कॉलम से आगे बढ़ते हैं कॉलम सूची में, आपको या तो कॉलम को GROUP BY . में जोड़ना होगा पंक्तियों के समूह का प्रतिनिधित्व करने के लिए एकल मान उत्पन्न करने के लिए क्लॉज या समग्र फ़ंक्शन का उपयोग करें।
यहां, हम type जोड़ते हैं GROUP BY . के लिए खंड, जिसका अर्थ है कि प्रत्येक पंक्ति type . के एक अद्वितीय संयोजन का प्रतिनिधित्व करेगी और color मूल्य। हम age . भी जोड़ते हैं कॉलम, संक्षेप में avg() प्रत्येक समूह की औसत आयु ज्ञात करने के लिए कार्य करें:
SELECT type, color, avg(age) AS average_age FROM pet GROUP BY type, color;
type | color | average_age--------+--------+-------------------- rabbit | brown | 7.0000000000000000 cat | black | 8.0000000000000000 rabbit | grey | 4.0000000000000000 dog | black | 7.0000000000000000 dog | brown | 2.0000000000000000 cat | orange | 8.0000000000000000 cat | white | 4.0000000000000000(7 rows)
सकल कार्य ठीक उसी तरह काम करते हैं जैसे GROUP BY . में एक कॉलम के साथ होता है खंड। यहाँ, हम प्रत्येक प्रकार के जानवर की औसत आयु ज्ञात करते हैं:
SELECT type, avg(age) AS average_age FROM PET GROUP BY type;
type | average_age--------+-------------------- rabbit | 6.0000000000000000 dog | 3.6666666666666667 cat | 6.6666666666666667(3 rows)
यदि हम प्रत्येक प्रकार के सबसे पुराने जानवर को प्रदर्शित करना चाहते हैं, तो हम इसके बजाय max() . का उपयोग कर सकते हैं age . पर कार्य करता है कॉलम। GROUP BY क्लॉज परिणामों को पहले की तरह ही पंक्तियों में समेट देता है, लेकिन नया फ़ंक्शन दूसरे कॉलम में परिणाम को बदल देता है:
SELECT type, max(age) AS oldest FROM pet GROUP BY type;
type | oldest--------+------- rabbit | 8 dog | 7 cat | 8(3 rows)
HAVING का उपयोग करना रिकॉर्ड के समूहों को फ़िल्टर करने के लिए खंड
GROUP BY क्लॉज एक प्रतिनिधि पंक्ति में कई रिकॉर्ड्स को संक्षिप्त करके डेटा को सारांशित करने का एक तरीका है। लेकिन क्या होगा यदि आप अतिरिक्त कारकों के आधार पर इन समूहों को सीमित करना चाहते हैं?
HAVING क्लॉज GROUP BY . के लिए एक संशोधक है खंड जो आपको उन शर्तों को निर्दिष्ट करने देता है जिन्हें परिणामों में शामिल करने के लिए प्रत्येक समूह को संतुष्ट करना होगा।
सामान्य सिंटैक्स इस तरह दिखता है:
SELECT <columns> FROM some_table GROUP BY <columns_to_group> HAVING <condition>
ऑपरेशन बहुत हद तक WHERE . के समान है खंड, इस अंतर के साथ कि WHERE एकल रिकॉर्ड और HAVING . को फ़िल्टर करता है रिकॉर्ड के समूहों को फ़िल्टर करता है।
HAVING का उपयोग करने वाले उदाहरण
उसी तालिका का उपयोग करके जिसे हमने पिछले अनुभाग में पेश किया था, हम प्रदर्शित कर सकते हैं कि HAVING . कैसे खंड काम करता है।
यहां, हम pet . की पंक्तियों को समूहित करते हैं type . में अद्वितीय मानों के आधार पर तालिका कॉलम, age . का न्यूनतम मान ज्ञात करना भी। HAVING क्लॉज फिर परिणामों को फ़िल्टर करके ऐसे किसी भी समूह को हटा देता है जहां आयु 1 से अधिक नहीं है:
SELECT type, min(age) AS youngest FROM pet GROUP BY type HAVING min(age) > 1;
type | youngest--------+---------- rabbit | 4 cat | 4(2 rows)
इस उदाहरण में, हम पंक्तियों को pet . में समूहित करते हैं उनके रंग से। फिर हम उन समूहों को फ़िल्टर करते हैं जो केवल एक पंक्ति का प्रतिनिधित्व करते हैं। परिणाम हमें हर रंग दिखाता है जो एक से अधिक बार दिखाई देता है:
SELECT color FROM pet GROUP BY color HAVING count(color) > 1;
color------- black brown(2 rows)
हम type . के संयोजन प्राप्त करने के लिए एक समान क्वेरी कर सकते हैं और color कि केवल एक ही जानवर के पास है:
SELECT type, color FROM pet GROUP BY type, color HAVING count(color) = 1;
type | color--------+-------- cat | black rabbit | grey dog | black cat | orange cat | white(5 rows)
LIMIT का उपयोग करना रिकॉर्ड की अधिकतम संख्या निर्धारित करने के लिए खंड
LIMIT क्लॉज आपके क्वेरी रिटर्न के रिकॉर्ड को कम करने के लिए एक अलग दृष्टिकोण प्रदान करता है। पंक्ति के भीतर ही मानदंड के आधार पर डेटा की पंक्तियों को समाप्त करने के बजाय, LIMIT क्लॉज एक क्वेरी द्वारा लौटाए गए रिकॉर्ड की अधिकतम संख्या निर्धारित करता है।
LIMIT . का मूल सिंटैक्स ऐसा दिखता है:
SELECT * FROM my_table LIMIT <num_rows> [OFFSET <num_rows_to_skip>];
यहां, <num_rows> निष्पादित क्वेरी से प्रदर्शित होने वाली पंक्तियों की अधिकतम संख्या को इंगित करता है। इसका उपयोग अक्सर ORDER BY . के संयोजन में किया जाता है एक निश्चित कॉलम में सबसे चरम मूल्यों वाली पंक्तियों को प्राप्त करने के लिए खंड। उदाहरण के लिए, किसी परीक्षा में पांच सर्वश्रेष्ठ अंक प्राप्त करने के लिए, उपयोगकर्ता ORDER BY . कर सकता है एक score कॉलम और फिर LIMIT परिणाम 5.
जबकि LIMIT डिफ़ॉल्ट रूप से परिणामों के शीर्ष से गिना जाता है, वैकल्पिक OFFSET कीवर्ड का उपयोग उसके द्वारा उपयोग की जाने वाली प्रारंभिक स्थिति को ऑफसेट करने के लिए किया जा सकता है। वास्तव में, यह आपको LIMIT द्वारा परिभाषित परिणामों की संख्या प्रदर्शित करके परिणामों के माध्यम से पृष्ठांकित करने की अनुमति देता है और फिर LIMIT . जोड़ना OFFSET . पर नंबर निम्नलिखित पृष्ठ को पुनः प्राप्त करने के लिए।
LIMIT का उपयोग करने वाले उदाहरण
हम pet का उपयोग करेंगे इस खंड में उदाहरणों के लिए पहले की तालिका।
जैसा कि ऊपर बताया गया है, LIMIT अक्सर ORDER BY . के साथ जोड़ा जाता है उचित संख्या को काटने से पहले पंक्तियों के क्रम को स्पष्ट रूप से परिभाषित करने के लिए खंड। यहां, हम pet . को सॉर्ट करते हैं उनकी age . के अनुसार प्रविष्टियां , सबसे पुराने से सबसे छोटे तक। फिर हम LIMIT . का उपयोग करते हैं शीर्ष 5 सबसे पुराने जानवरों को प्रदर्शित करने के लिए:
SELECT * FROM pet ORDER BY age DESC LIMIT 5;
type | name | color | age | id--------+---------+--------+-----+---- cat | Simon | orange | 8 | 6 cat | Sabrina | black | 8 | 4 rabbit | Bunny | brown | 8 | 8 dog | Rover | black | 7 | 2 rabbit | Briany | brown | 6 | 9(5 rows)
बिना ORDER BY . के खंड, LIMIT पूरी तरह से अनुमानित तरीके से चयन करेगा। लौटाए गए परिणाम तालिका के भीतर या अनुक्रमणिका द्वारा प्रविष्टियों के क्रम से प्रभावित हो सकते हैं। यह हमेशा बुरी बात नहीं होती है।
अगर हमें किसी एक dog . के लिए एक रिकॉर्ड चाहिए तालिका के भीतर, हम इस तरह की एक क्वेरी बना सकते हैं। ध्यान रखें कि हालांकि परिणाम की भविष्यवाणी करना मुश्किल हो सकता है, यह एक यादृच्छिक चयन नहीं है और इसका उपयोग इस तरह नहीं किया जाना चाहिए:
SELECT * FROM pet WHERE type = 'dog' LIMIT 1;
type | name | color | age | id------+------+-------+-----+---- dog | Spot | brown | 3 | 1(1 row)
हम OFFSET . का उपयोग कर सकते हैं परिणामों के माध्यम से पृष्ठांकित करने के लिए खंड। हम एक ORDER BY . शामिल करते हैं परिणामों के लिए एक विशिष्ट क्रम को परिभाषित करने के लिए खंड।
पहली क्वेरी के लिए, हम OFFSET . निर्दिष्ट किए बिना परिणामों को सीमित कर देते हैं पहली 3 सबसे कम उम्र की प्रविष्टियाँ प्राप्त करने के लिए:
SELECT * FROM pet ORDER BY age LIMIT 3;
type | name | color | age | id------+-------+-------+-----+---- dog | Sally | brown | 1 | 3 dog | Spot | brown | 3 | 1 cat | Felix | white | 4 | 5(3 rows)
अगले 3 सबसे कम उम्र पाने के लिए, हम LIMIT . में परिभाषित संख्या जोड़ सकते हैं करने के लिए OFFSET उन परिणामों को छोड़ने के लिए जिन्हें हम पहले ही प्राप्त कर चुके हैं:
SELECT * FROM pet ORDER BY age LIMIT 3 OFFSET 3;
type | name | color | age | id --------+---------+-------+-----+---- rabbit | Buttons | grey | 4 | 7 rabbit | Briany | brown | 6 | 9 dog | Rover | black | 7 | 2(3 rows)
अगर हम LIMIT जोड़ते हैं करने के लिए OFFSET फिर से, हम अगले 3 परिणाम प्राप्त करेंगे:
SELECT * FROM pet ORDER BY age LIMIT 3 OFFSET 6;
type | name | color | age | id--------+---------+--------+-----+---- cat | Simon | orange | 8 | 6 rabbit | Bunny | brown | 8 | 8 cat | Sabrina | black | 8 | 4(3 rows)
यह हमें प्रबंधनीय भागों में क्वेरी से डेटा की पंक्तियों को पुनः प्राप्त करने देता है।
निष्कर्ष
प्रश्नों से आपको मिलने वाले परिणामों को फ़िल्टर करने और अन्यथा बाधित करने के कई तरीके हैं। WHERE . जैसे खंड और HAVING संभावित पंक्तियों या पंक्तियों के समूहों का मूल्यांकन करके देखें कि क्या वे कुछ मानदंडों को पूरा करते हैं। GROUP BY क्लॉज आपको एक या एक से अधिक कॉलम वैल्यू वाले रिकॉर्ड्स को एक साथ ग्रुप करके डेटा को सारांशित करने में मदद करता है। LIMIT क्लॉज उपयोगकर्ताओं को पुनः प्राप्त करने के लिए रिकॉर्ड की संख्या पर एक कठिन अधिकतम सेट करने की क्षमता प्रदान करता है।
व्यक्तिगत रूप से या संयोजन में इन खंडों को कैसे लागू किया जा सकता है, यह सीखना, आपको बड़े डेटासेट से विशिष्ट डेटा निकालने की अनुमति देगा। पोस्टग्रेएसक्यूएल में रहने वाले डेटा को उपयोगी उत्तरों में बदलने के लिए क्वेरी संशोधक और फ़िल्टर आवश्यक हैं।
