SQL में, COUNT() फ़ंक्शन एक समग्र फ़ंक्शन है जो समूह में पाए जाने वाले आइटम की संख्या देता है।
आप COUNT() . का उपयोग कर सकते हैं एक क्वेरी के कई हिस्सों में। उदाहरण के लिए, आप इसे SELECT . में इस्तेमाल कर सकते हैं सूची, या HAVING समूह फ़िल्टर करते समय खंड।
नमूना तालिका
मान लीजिए हमारे पास निम्न तालिका है:
SELECT * FROM Pets;परिणाम:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
निम्नलिखित उदाहरण COUNT() का उपयोग करेंगे इस तालिका को क्वेरी करते समय कार्य करें।
उदाहरण
आरंभ करने के लिए यहां एक सरल उदाहरण दिया गया है।
SELECT COUNT(*) AS Count
FROM Pets;परिणाम:
+---------+ | Count | |---------| | 8 | +---------+
यह बताता है कि तालिका में 8 पंक्तियाँ हैं। हम जानते हैं कि क्योंकि हमने तारकीय वाइल्डकार्ड (* .) का उपयोग किया था ) सभी पंक्तियों और सभी स्तंभों को निर्दिष्ट करने के लिए।
एक विशिष्ट कॉलम की गणना करें
आप गिनने के लिए एक विशेष कॉलम भी निर्दिष्ट कर सकते हैं। COUNT() फ़ंक्शन केवल गैर-NULL की गणना करता है परिणाम, इसलिए यदि आप एक कॉलम निर्दिष्ट करते हैं जिसमें NULL . है मान, उन मानों की गणना नहीं की जाएगी।
मेरा मतलब दिखाने के लिए यहां एक उदाहरण दिया गया है।
SELECT COUNT(DOB) AS Count
FROM Pets;परिणाम:
+---------+ | Count | |---------| | 6 | +---------+ Warning: Null value is eliminated by an aggregate or other SET operation.
इस मामले में, Pets तालिका में दो NULL शामिल हैं DOB . में मान कॉलम (दो पालतू जानवरों ने अपनी जन्मतिथि नहीं दी है), और इसलिए COUNT(DOB) जब हमने COUNT(*) . का उपयोग किया तो 8 के बजाय 6 लौटाता है .
कारण COUNT(*) पिछले उदाहरण में सभी पंक्तियों को लौटा दिया, क्योंकि उन दो पंक्तियों ने किया अन्य कॉलम में डेटा है।
मेरे उदाहरण में, मेरे डीबीएमएस ने इस बारे में एक चेतावनी भी दी। आपके DBMS और आपके विशिष्ट कॉन्फ़िगरेशन के आधार पर आपको चेतावनी मिल भी सकती है और नहीं भी।
फ़िल्टर किए गए परिणाम
COUNT() फ़ंक्शन क्वेरी द्वारा लौटाई गई पंक्तियों की गणना करता है। इसलिए यदि आप परिणामों को फ़िल्टर करते हैं, तो COUNT() . का परिणाम प्रतिबिंबित करेंगे।
SELECT COUNT(*) AS Count
FROM Pets
WHERE PetName = 'Fluffy';परिणाम:
+---------+ | Count | |---------| | 2 | +---------+
इस मामले में, Fluffy नाम के दो पालतू जानवर हैं। इसलिए, दो पंक्तियों को क्वेरी द्वारा वापस कर दिया गया होगा, और परिणाम COUNT() है 2 ।
विभिन्न स्तंभों की गणना करें
डिफ़ॉल्ट रूप से, COUNT() फ़ंक्शन में एक अंतर्निहित ALL शामिल है खोजशब्द। इसका मतलब है कि इसके परिणामों में डुप्लीकेट शामिल हैं।
लेकिन आपके पास DISTINCT . जोड़ने का विकल्प भी है कीवर्ड निर्दिष्ट करने के लिए कि केवल विशिष्ट मान लौटाए जाते हैं। यानी, आप निर्दिष्ट कर सकते हैं कि इसमें डुप्लीकेट शामिल नहीं हैं।
आइए चुनें PetName कॉलम। यदि आप उपरोक्त मूल तालिका को देखते हैं, तो आप देख सकते हैं कि PetName कॉलम में समान मान वाली दो पंक्तियाँ शामिल हैं (Fluffy )।
सबसे पहले हम एक COUNT(ALL PetName) चलाएंगे गणना में सभी डुप्लिकेट मानों को शामिल करने के लिए क्वेरी:
SELECT COUNT(ALL PetName) AS Count
FROM Pets;परिणाम:
+---------+ | Count | |---------| | 8 | +---------+
तो, आठ पंक्तियाँ हैं। याद रखें कि अगर हम ALL . को शामिल नहीं करते तो यह वही परिणाम होता जो हमें मिलता कीवर्ड, क्योंकि ALL डिफ़ॉल्ट है।
अब हम एक COUNT(DISTINCT PetName) चलाएंगे गिनती से किसी भी डुप्लीकेट को खत्म करने के लिए।
SELECT COUNT(DISTINCT PetName) AS Count
FROM Pets;परिणाम:
+---------+ | Count | |---------| | 7 | +---------+
इस बार परिणाम 7 . है . ऐसा इसलिए है क्योंकि हमारे डुप्लिकेट मूल्य को समाप्त कर दिया गया था। यानी, डुप्लीकेट मान को केवल एक मान के रूप में माना जाता था।
COUNT() का उपयोग करना HAVING . के साथ खंड
आप COUNT() . शामिल कर सकते हैं एक क्वेरी के कई हिस्सों में कार्य करता है। यह केवल SELECT . तक ही सीमित नहीं है सूची।
यहां एक उदाहरण दिया गया है जो COUNT() . का उपयोग करता है दोनों में HAVING खंड और SELECT सूची।
SELECT
PetTypeId,
COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;परिणाम:
+-------------+---------+ | PetTypeId | Count | |-------------+---------| | 3 | 4 | | 2 | 3 | +-------------+---------+
इस मामले में, हमने HAVING . का उपयोग किया है GROUP BY . के संयोजन में क्लॉज केवल उन पंक्तियों को वापस करने के लिए खंड जिनमें COUNT(PetTypeId) . है 2 . से अधिक का .
आप केवल ) ऑपरेटर फॉर बिगिनर्स तक सीमित नहीं हैं">ऑपरेटर से बड़ा (> ) HAVING . का उपयोग करते समय खंड। आप उन्हीं ऑपरेटरों का उपयोग कर सकते हैं जिनका उपयोग आप WHERE . के साथ कर सकते हैं खंड (जैसे = , ) Operator for Beginners">< , =) Operator for Beginners">>= , IN , LIKE , आदि)।
SQL में उपलब्ध ऑपरेटरों की सूची के लिए SQL ऑपरेटर्स देखें।
विंडो फ़ंक्शंस
आपके DBMS के आधार पर, आप OVER . का उपयोग करने में सक्षम हो सकते हैं आपके COUNT() . के साथ क्लॉज विंडो फ़ंक्शन बनाने के लिए फ़ंक्शन।
एक विंडो फ़ंक्शन क्वेरी पंक्तियों के एक सेट पर एक समग्र-जैसा ऑपरेशन करता है। यह प्रत्येक क्वेरी पंक्ति के लिए परिणाम उत्पन्न करता है। यह एक समग्र ऑपरेशन के विपरीत है, जो क्वेरी पंक्तियों को एक परिणाम पंक्ति में समूहित करता है।
अवधारणा को प्रदर्शित करने के लिए यहां एक उदाहरण दिया गया है।
हम पहले ही देख चुके हैं Pets टेबल। हमारे डेटाबेस में एक Owners भी है तालिका, और इसमें निम्न डेटा शामिल है:
+-----------+-------------+------------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | |-----------+-------------+------------+----------------+-------------------| | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 3 | Nancy | Simpson | (489) 591-0408 | NULL | | 4 | Boris | Trump | (349) 611-8908 | NULL | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +-----------+-------------+------------+----------------+-------------------+
हम इन तालिकाओं से डेटा पुनर्प्राप्त कर सकते हैं और उन्हें एक परिणाम सेट के रूप में शामिल होने का उपयोग करके प्रस्तुत कर सकते हैं।
हम COUNT() . का भी उपयोग कर सकते हैं OVER . के साथ कार्य करें डेटा पर विंडो फ़ंक्शन लागू करने के लिए क्लॉज।
SELECT
CONCAT(o.FirstName, ' ', o.LastName) AS Owner,
p.PetName,
COUNT(PetId) OVER (PARTITION BY CONCAT(o.FirstName, ' ', o.LastName)) AS "Number of pets from this owner"
FROM Owners o
INNER JOIN Pets p
ON p.OwnerId = o.OwnerId
ORDER BY "Number of pets from this owner" DESC;परिणाम:
+---------------+-----------+----------------------------------+ | Owner | PetName | Number of pets from this owner | |---------------+-----------+----------------------------------| | Nancy Simpson | Wag | 3 | | Nancy Simpson | Fluffy | 3 | | Nancy Simpson | Fetch | 3 | | Bart Pitt | Scratch | 2 | | Bart Pitt | Bark | 2 | | Boris Trump | Meow | 2 | | Boris Trump | Fluffy | 2 | | Homer Connery | Tweet | 1 | +---------------+-----------+----------------------------------+
इस मामले में हमने OVER . का इस्तेमाल किया हमारे COUNT() . के साथ क्लॉज केवल मालिक के नाम पर गिनती को विभाजित करने के लिए खंड।
नतीजा यह है कि कई पालतू जानवरों वाले मालिकों को कई पंक्तियों पर प्रदर्शित किया जाता है (क्योंकि प्रत्येक पालतू जानवर को भी प्रदर्शित किया जाना है), और प्रत्येक पंक्ति में उस मालिक के पालतू जानवरों की कुल संख्या होती है।
इस अवधारणा को SQL में अन्य समग्र कार्यों पर भी लागू किया जा सकता है, जैसे SUM() , MIN() , MAX() , और AVG() ।
COUNT_BIG()
यदि आप SQL सर्वर में गंभीरता से बड़े डेटा सेट की गणना कर रहे हैं, तो आप पा सकते हैं कि COUNT() संख्या बहुत अधिक होने के कारण फ़ंक्शन त्रुटि उत्पन्न करता है। ऐसा केवल तभी होगा जब आपकी गिनती 2,147,483,647 से अधिक हो।
ऐसे मामलों में, आप COUNT_BIG() . का उपयोग कर सकते हैं , जो बहुत बड़ी संख्या को पूरा कर सकता है।
देखें कैसे COUNT_BIG() SQL सर्वर और COUNT() में काम करता है बनाम COUNT_BIG() अधिक विस्तृत स्पष्टीकरण के लिए।
एएनएसआई एसक्यूएल मानक
COUNT() फ़ंक्शन SQL मानक में सूचीबद्ध है, और यह प्रमुख डीबीएमएस के अधिकांश (यदि सभी नहीं) में उपलब्ध है, और उन पर काफी समान काम करता है।
विभिन्न DBMS में किए गए कोड उदाहरणों के लिए, SQLite देखें COUNT() , SQL सर्वर COUNT() , और MySQL COUNT() ।
