SQL ग्रुपिंग और टोटलिंग का परिचय

SQL के सबसे शक्तिशाली पहलुओं में से एक डेटा एकत्रीकरण करने की क्षमता है। सबसे शक्तिशाली SQL डेटा एकत्रीकरण टूल में से दो हैं ग्रुपिंग और कुल . इस गाइड में, आप ग्रुपिंग और टोटल का उपयोग करके SQL डेटा एकत्रीकरण सीखते हैं।

SQL एग्रीगेट फंक्शन्स

SQL में, एकत्रीकरण मूल्यों के एक सेट के संचालन या गणना की प्रक्रिया है। इरादा एक सारांश मूल्य वापस करना है। SQL में कई बहुत शक्तिशाली समग्र कार्य शामिल हैं जैसे AVG() , COUNT() , SUM() , MAX() , और MIN() . बदले में, ये फ़ंक्शन अक्सर SQL कथनों में पाए जाते हैं जो GROUP BY . को लागू करते हैं खंड। हालांकि, इन कार्यों को उस खंड से संबद्ध करने की आवश्यकता नहीं है।

नोट जब तक अन्यथा उल्लेख न किया गया हो, इस गाइड में प्रदर्शित सभी डेटाबेस कमांड MySQL . दोनों पर अच्छी तरह से काम करते हैं और PostgreSQL .

यह मार्गदर्शिका CourseTaken का उपयोग करती है समग्र कार्यों को प्रदर्शित करने के लिए तालिका। कमांड लाइन से, CourseTaken बनाएं टेबल।

CREATE TABLE CourseTaken (
    SSNumber CHAR(9) NOT NULL,
    CourseId CHAR(6) NOT NULL,
    NumericGrade INT NOT NULL,
    YearTaken INT NOT NULL
);

CourseTaken तालिका में निम्न स्तंभ डेटा है:

एकल सारांश मान की गणना के लिए SQL एग्रीगेट फ़ंक्शन का उपयोग करें

नीचे दिए गए अनुभाग अलग-अलग उदाहरण प्रदान करते हैं जो एकल सारांश मान वापस करने के लिए समग्र फ़ंक्शन का उपयोग करते हैं। सभी उदाहरण CourseTaken . का उपयोग करते हैं तालिका जो मार्गदर्शिका के समग्र कार्य अनुभाग में बनाई गई थी।

उदाहरण 1:

इस उदाहरण में, कुल फ़ंक्शन CSC101 . पाठ्यक्रम लेने वाले सभी छात्रों के लिए एक संख्यात्मक औसत ग्रेड देता है वर्ष 2022 में।

SELECT AVG(NumericGrade) AS 'Avg Grade'
FROM CourseTaken
WHERE CourseId = 'CSC101
AND YearTaken = 2022;

SQL निम्न औसत ग्रेड देता है:

Avg Grade
---------
92

उदाहरण 2:

नीचे दिया गया समग्र फ़ंक्शन CSC101 course कोर्स करने वाले छात्रों की संख्या की गणना करता है वर्ष 2022 से पहले।

SELECT COUNT(SSNumber) AS 'Student Count'
FROM CourseTaken
WHERE CourseId = 'CSC101'
AND YearTaken < 2022;

निम्नलिखित गिनती लौटा दी गई है:

Student Count
---------
1

उदाहरण 3:

इस उदाहरण में, CSC101 लेने वाले छात्र द्वारा किसी भी वर्ष में दर्ज अधिकतम अंकीय ग्रेड प्राप्त करने के लिए एक समग्र फ़ंक्शन का उपयोग किया जाता है ।

SELECT MAX(NumericGrade) AS 'Max Grade'
FROM CourseTaken
WHERE CourseId = 'CSC101'

लौटाया गया अधिकतम ग्रेड निम्नलिखित है:

Max Grade
---------
100

ग्रुप फंक्शन्स का उपयोग करके डेटा को एग्रीगेट करें

निम्नलिखित उदाहरण GROUP BY . के उपयोग को प्रदर्शित करते हैं CourseTaken . से डेटा का उपयोग करते हुए क्लॉज टेबल।

उदाहरण 1:

नीचे दिया गया उदाहरण प्रत्येक छात्र के लिए अब तक लिए गए सभी पाठ्यक्रमों के लिए औसत ग्रेड निर्धारित करता है। इसे निष्पादित करने के लिए, SQL Group By . का उपयोग करें छात्र द्वारा समूह के लिए खंड (इस मामले में, SSNumber कॉलम)।

SELECT SSNumber, AVG(NumericGrade) AS 'Avg Grade'
FROM CourseTaken
GROUP BY SSNumber

आउटपुट प्रत्येक छात्र के लिए औसत ग्रेड देता है।

+-----------+----------+
| SSNumber  | Avg Grade|
+-----------+----------+
| 111111111 | 96.5     |
| 222222222 | 87.5     |
| 333333333 | 88       |
+-----------+----------+

उदाहरण 2:

नीचे दिया गया समग्र कार्य प्रत्येक CourseId . में प्राप्त औसत ग्रेड का पता लगाता है CourseTaken . में टेबल। ऐसा करने के लिए, CourseId . द्वारा समूहित करें YearTaken निम्न SQL कोड के साथ:

SELECT CourseId AS 'Course', YearTaken AS 'Year',
AVG(NumericGrade) AS 'Avg Grade'
FROM CourseTaken
GROUP BY CourseId, YearTaken
ORDER BY CourseId, YearTaken

आपको निम्न आउटपुट देखना चाहिए:

+--------+------+-----------+
| Course | Year | Avg Grade |
+--------+------+-----------+
| CSC101 | 2021 | 98        |
| POL101 | 2021 | 92        |
| CSC101 | 2022 | 92        |
| EEE101 | 2022 | 75        |
| ENG101 | 2022 | 95        |
+--------+------+-----------+

नोट उपरोक्त उदाहरण थोड़ा अधिक जटिल है। आप एक के बजाय दो स्तंभों के आधार पर समूहबद्ध करते हैं (CourseId Year . के भीतर ) इसलिए, आप CSC101 . द्वारा औसत ग्रेड और समूह की गणना करते हैं वर्ष के लिए 2021 CSC101 . के औसत ग्रेड से अलग वर्ष के लिए 2022 . कोर्स CSC101 वर्ष के लिए 2022 दो पंक्तियों का एक एकत्रीकरण है, जबकि अन्य सभी समूह द्वारा पंक्तियाँ एक पंक्ति का एकत्रीकरण हैं। इसके अतिरिक्त, आदेश देना . की अवधारणा से (Order By खंड) आप CourseTaken . द्वारा आदेशित परिणाम (क्रमबद्ध) प्रदर्शित कर सकते हैं किसी दिए गए वर्ष के भीतर।

उदाहरण 3:

पिछले उदाहरण में SQL क्वेरी से, आप WHERE जोड़कर आपके द्वारा संचालित पंक्तियों की संख्या को सीमित कर सकते हैं क्वेरी के लिए खंड। उदाहरण के लिए, छात्रों द्वारा केवल CourseId . के लिए प्राप्त औसत ग्रेड उत्पन्न करने के लिए CSC101 , CourseId . द्वारा समूहित करें YearTaken . निम्न SQL कोड इसे पूरा कर सकता है:

SELECT CourseId AS 'Course', YearTaken AS 'Year',
AVG(NumericGrade) AS 'Avg Grade'
FROM CourseTaken
WHERE CourseId = 'CSC101'
GROUP BY CourseId, YearTaken
ORDER BY CourseId, YearTaken

उपरोक्त SQL कोड में, आप एक शर्त जोड़ रहे हैं (WHERE . के माध्यम से) क्लॉज) वास्तविक समूह एकत्रीकरण से पहले (GROUP BY . के माध्यम से) खंड)।

निम्न आउटपुट लौटाया जाता है:

+--------+------+-----------+
| Course | Year | Avg Grade |
+--------+------+-----------+
| CSC101 | 2021 | 98        |
| CSC101 | 2022 | 92        |
+--------+------+-----------+

उदाहरण 4:

उदाहरण 2 में SQL क्वेरी से, आप अंतिम परिणाम वापस आने से पहले एक शर्त लागू कर सकते हैं। इसे पूरा करने के लिए SQL Having . का उपयोग करें खंड। आप प्रत्येक CourseId . में औसत ग्रेड निर्धारित कर सकते हैं , जहां कुल औसत ग्रेड 90 . से अधिक है . आप फिर से CourseId . के आधार पर समूह बना सकते हैं YearTaken . निम्न SQL कोड इसे पूरा कर सकता है:

SELECT CourseId AS ‘Course’, YearTaken AS ‘Year’,
AVG(NumericGrade) AS ‘Avg Grade’
FROM CourseTaken
GROUP BY CourseId, YearTaken
HAVING AVG(NumericGrade) > 90
ORDER BY CourseId, YearTaken

आउटपुट निम्न है:

+--------+------+-----------+
| Course | Year | Avg Grade |
+--------+------+-----------+
| CSC101 | 2021 | 98        |
| POL101 | 2021 | 92        |
| CSC101 | 2022 | 92        |
| ENG101 | 2022 | 95        |
+--------+------+-----------+

CourseId . के लिए पंक्ति EEE101 वापस नहीं किया गया था। ऐसा इसलिए है क्योंकि Having GROUP BY . के बाद क्लॉज ने इसे फ़िल्टर कर दिया खंड निष्पादित किया गया था (CourseId EEE101 का औसत ग्रेड 90 से नीचे है)।

उदाहरण 5:

उदाहरण 3 . से SQL कोड पर निर्माण और उदाहरण 4 , आप एकत्रीकरण क्वेरी बना सकते हैं जो Where . दोनों का उपयोग करती हैं और Having खंड। उदाहरण के लिए, आप उन पाठ्यक्रमों को निर्धारित कर सकते हैं जो 2021 . में लिए गए थे , जहां लिए गए उन पाठ्यक्रमों के लिए औसत ग्रेड 93 . से अधिक था . यहाँ, Where क्लॉज Group By . से पहले परिणामों को फ़िल्टर करता है डेटा एकत्रीकरण किया जाता है, और Having क्लॉज Group By . के बाद लौटे परिणामों को फ़िल्टर करता है डेटा एकत्रीकरण किया जाता है। निम्न SQL कोड इसे पूरा कर सकता है:

SELECT CourseId AS ‘Course’, YearTaken AS ‘Year’,
AVG(NumericGrade) AS ‘Avg Grade’
FROM CourseTaken
WHERE YearTaken = 2021
GROUP BY CourseId, YearTaken
HAVING AVG(NumericGrade) > 93
ORDER BY CourseId

लौटाया गया आउटपुट निम्न है:

+--------+------+-----------+
| Course | Year | Avg Grade |
+--------+------+-----------+
| CSC101 | 2021 | 98        |
+--------+------+-----------+

उदाहरण 6:

आप प्रत्येक Group By . से जुड़ी पंक्तियों की संख्या गिन सकते हैं एक प्रश्न में एकत्रीकरण। पिछले उदाहरण SQL कोड के आधार पर, आप Students . द्वारा प्राप्त औसत ग्रेड उत्पन्न कर सकते हैं केवल CourseId . के लिए CSC101 , CourseId . द्वारा समूहीकृत YearTaken . कोड को प्रत्येक समूह से जुड़े छात्रों (गिनती) की संख्या प्रदान करनी चाहिए। निम्न SQL कोड इसे पूरा कर सकता है:

SELECT CourseId AS ‘Course’, YearTaken AS ‘Year’,
AVG(NumericGrade) AS ‘Avg Grade’,
Count(SSNumber) AS ‘Count’
FROM CourseTaken
WHERE CourseId = ‘CSC101’
GROUP BY CourseId, YearTaken
ORDER BY CourseId, YearTaken

Count(SSNumber) SELECT . में खंड को Count(*) . के रूप में निर्दिष्ट किया जा सकता था . दो सिंटैक्स के बीच का अंतर यह है कि Count(*) ऐसी पंक्तियाँ शामिल हैं जिनमें NULL . है उनमें भी मूल्य। CourseTaken . के अनुसार ऊपर दी गई तालिका परिभाषा, CourseTaken में सभी कॉलम तालिका में गैर-शून्य मान होना चाहिए (NOT NULL विशेषता यह आश्वासन देती है)। Count(SSNumber) और Count(*) इस उदाहरण में कार्यात्मक रूप से समतुल्य होगा।

निम्न आउटपुट लौटाया जाता है:

+--------+------+-----------+-------+
| Course | Year | Avg Grade | Count |
+--------+------+-----------+-------+
| CSC101 | 2021 | 98        | 1     |
| CSC101 | 2022 | 92        | 2     |
+--------+------+-----------+-------+

निष्कर्ष

यह मार्गदर्शिका समूहीकरण और योग के लिए SQL के शक्तिशाली डेटा एकत्रीकरण कार्यों के लिए बिल्डिंग ब्लॉक्स प्रदान करती है। जैसा कि नोट किया गया है, आप Where . का उपयोग करके उन मानों को प्रतिबंधित कर सकते हैं जो इन समूहों का हिस्सा बन जाते हैं एकत्रीकरण प्रदर्शन से पहले प्रश्नों में खंड। आप Having का उपयोग करके समूहीकृत परिणामों की पंक्तियों को फ़िल्टर कर सकते हैं (एकत्रीकरण के बाद) SQL क्वेरीज़ में क्लॉज।