मारियाडीबी में COUNT () फ़ंक्शन

मारियाडीबी में, COUNT() एग्रीगेट फ़ंक्शन SELECT द्वारा पुनर्प्राप्त पंक्तियों में किसी व्यंजक के गैर-शून्य मानों की संख्या की संख्या देता है बयान।

नमूना डेटा

मान लीजिए हमारे पास निम्न तालिका है:

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(*)
FROM Pets;

परिणाम:

8

यह बताता है कि तालिका में 8 पंक्तियाँ हैं। हम जानते हैं कि क्योंकि हमने तारकीय वाइल्डकार्ड (* .) का उपयोग किया था ) सभी पंक्तियों और सभी स्तंभों को निर्दिष्ट करने के लिए।

एक विशिष्ट कॉलम की गणना करें

आप गिनने के लिए एक कॉलम भी निर्दिष्ट कर सकते हैं। COUNT() फ़ंक्शन केवल गैर-NULL की गणना करता है परिणाम, इसलिए यदि आप एक कॉलम निर्दिष्ट करते हैं जिसमें NULL . है मान, उन मानों की गणना नहीं की जाएगी।

मेरा मतलब दिखाने के लिए यहां एक उदाहरण दिया गया है।

SELECT COUNT(DOB)
FROM Pets;

परिणाम:

6

इस मामले में, Pets तालिका में दो NULL शामिल हैं DOB . में मान कॉलम (दो पालतू जानवरों ने अपनी जन्मतिथि नहीं दी है), और इसलिए COUNT(DOB) जब हमने COUNT(*) . का उपयोग किया तो 8 के बजाय 6 लौटाता है .

कारण COUNT(*) पिछले उदाहरण में सभी पंक्तियों को लौटा दिया, क्योंकि उन दो पंक्तियों ने किया अन्य कॉलम में डेटा है।

फ़िल्टर किए गए परिणाम

COUNT() फ़ंक्शन क्वेरी द्वारा लौटाई गई पंक्तियों की गणना करता है। इसलिए यदि आप परिणामों को फ़िल्टर करते हैं, तो COUNT() . का परिणाम प्रतिबिंबित करेगा।

SELECT COUNT(*)
FROM Pets
WHERE PetName = 'Fluffy';

परिणाम:

2

इस मामले में, Fluffy नाम के दो पालतू जानवर हैं। इसलिए, दो पंक्तियों को क्वेरी द्वारा वापस कर दिया गया होगा, और परिणाम COUNT() है 2 ।

विभिन्न स्तंभों की गणना करें

हमारे पास DISTINCT . जोड़ने का विकल्प है कीवर्ड यह निर्दिष्ट करने के लिए कि केवल विशिष्ट मान लौटाए गए हैं (ताकि इसमें डुप्लिकेट शामिल न हों):

SELECT 
    COUNT(PetName) AS "All",
    COUNT(DISTINCT PetName) AS "Distinct"
FROM Pets;

परिणाम:

+-----+----------+
| All | Distinct |
+-----+----------+
|   8 |        7 |
+-----+----------+

इस मामले में, भले ही आठ PetName हों मान, उनमें से केवल सात अलग हैं (दो डुप्लीकेट हैं - हमारे पास Fluffy नामक दो पालतू जानवर हैं)।

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       |
+-------------+---------+

SQL देखें COUNT() शुरुआती लोगों के लिए इस उदाहरण की अधिक विस्तृत व्याख्या के साथ-साथ COUNT() का उपयोग करने का एक उदाहरण एक विंडो फ़ंक्शन में।