Theory
Principal को प्रति subject एक line चाहिए
ResultDesk का अगला request सादा लगता है: "हर subject का average score, worst पहले, और उन subjects को flag कीजिए जिनका average 50 से कम है।"
आप BCA105 से AVG जानते हैं, पर पूरी marks table पर AVG पूरी college के लिए एक नंबर देता है। Principal को प्रति subject एक line चाहिए: DBMS 61.5, Maths 73.2, ...
आपको हज़ारों rows को प्रति group एक summary row में fold करने का एक तरीक़ा चाहिए, फिर उन summaries को filter और sort करना है। यही बिल्कुल GROUP BY toolkit है।
Theory
Answer sheets को ढेरों में sort करना
एक table पर हर answer sheet डाल दीजिए: chaos। अब प्रति subject एक ढेर बनाइए, और प्रति ढेर एक slip लिखिए: ढेर का नाम, average, count।
GROUP BY ढेर बनाता है। Aggregates हर ढेर का slip लिखते हैं। HAVING पूरे ढेर फेंक देता है जो एक test fail करते हैं (average 50 से कम)। ORDER BY पढ़ने के लिए बचे slips arrange करता है। ढेर बनने के बाद आप कभी individual sheets नहीं देखते: सिर्फ़ slips।
Theory
GROUP BY और HAVING, formally
GROUP BY col col की एक value share करती सभी rows को एक output row में collapse करता है; हर दूसरे selected column को एक aggregate में wrap होना चाहिए।
HAVING aggregation के बाद groups filter करता है, और यह एकमात्र जगह है जहाँ एक condition में aggregate आ सकता है।
वह distinction जो exams कभी पूछना नहीं छोड़ते:
- WHERE: rows filter करता है, grouping से पहले चलता है, aggregates मना।
- HAVING: groups filter करता है, grouping के बाद चलता है, aggregates allowed।
Practical
Principal का request, एक query
SELECT subject,
AVG(score) AS average,
COUNT(*) AS papers
FROM marks
WHERE score IS NOT NULL -- row filter, BEFORE piles form
GROUP BY subject -- one pile per subject
HAVING AVG(score) < 50 -- keep only weak piles
ORDER BY average ASC; -- worst first
-- grade bands with CASE (if-else inside a query):
SELECT roll, score,
CASE
WHEN score >= 70 THEN 'Distinction'
WHEN score >= 40 THEN 'Pass'
ELSE 'Fail'
END AS grade
FROM marks
WHERE subject = 'DBMS';
This example runs in Gri-Learn on the web, where you can edit it and see the output.
Theory
ORDER BY और CASE, finishing tools
ORDER BY average ASC output sort करता है: ASC (छोटे से बड़े) default है, DESC उलट देता है। Multiple keys काम करते हैं: ORDER BY subject ASC, score DESC।
CASE SQL का if-else expression है:
CASE WHEN test THEN value WHEN test THEN value ELSE value END
Conditions top to bottom, first match जीतता है check होते हैं: score 85 >= 70 branch को hit करता है और कभी >= 40 तक नहीं पहुँचता। अपने WHENs को strictest से loosest order में रखिए वरना हर row पहले loose branch में उतर जाती है।
Quiz
एक student लिखता है: SELECT subject, AVG(score) FROM marks WHERE AVG(score) < 50 GROUP BY subject; और एक error पाता है। क्यों?
- Aggregates WHERE में नहीं आ सकते; group conditions GROUP BY के बाद HAVING में रहते हैं
- AVG को GROUP BY के साथ इस्तेमाल नहीं किया जा सकता
- WHERE को हमेशा GROUP BY के बाद आना चाहिए
- Query में ORDER BY missing है
Show the answer
Aggregates WHERE में नहीं आ सकते; group conditions GROUP BY के बाद HAVING में रहते हैं
WHERE ढेर बनने से पहले चलता है, जब AVG(score) अभी मौजूद नहीं है, तो वहाँ aggregates मना हैं। Fix: condition को GROUP BY के बाद HAVING AVG(score) < 50 में move कीजिए। Option B उल्टा है (GROUP BY के साथ AVG standard जोड़ी है), option C fixed clause order तोड़ता है (WHERE GROUP BY से पहले आता है), और ORDER BY optional polish है, कभी इस error की वजह नहीं।
Think first
Grade bands trace कीजिए
DBMS में Scores: 85, 62, 38, 70। CASE WHEN score >= 70 THEN 'Distinction' WHEN score >= 40 THEN 'Pass' ELSE 'Fail' END इस्तेमाल करते हुए, हर score को इसका grade दीजिए। 70 और 38 से सावधान रहें।
Show the answer
85 → Distinction। 62 → Pass। 38 → Fail (दोनों tests fail करता है, ELSE तक गिरता है)। 70 → Distinction (>= 70 EXACTLY 70 पर true है; first match जीतता है और evaluation रुकता है)।
दो hinge cases हैं boundary (70 Distinction गिनता है क्योंकि >= में equality शामिल है) और fall-through (38 ELSE तक पहुँचता है)। Exams बिल्कुल इन दो rows पर पूरे सवाल बनाते हैं।
Watch out
Clause order negotiable नहीं है
SELECT ... FROM ... WHERE ... GROUP BY ... HAVING ... ORDER BY ... LIMIT
इन्हें किसी और order में लिखिए और SQLite error देता है। इस sequence को उसी flow से याद कीजिए: rows filter कीजिए (WHERE), ढेर बनाइए (GROUP BY), ढेर filter कीजिए (HAVING), slips arrange कीजिए (ORDER BY), ऊपर के कुछ लीजिए (LIMIT)। और एक CASE में, सबसे strict WHEN पहले रखिए: conditions top to bottom test होते हैं।
Theory
यह फिर कहाँ दिखता है
Unit 4 बिल्कुल यही lesson pandas में replay करता है: GROUP BY df.groupby('subject') बनता है, HAVING grouped result पर एक filter बनता है, CASE एक mapping function बनता है। SQL version को cold सीखिए और pandas version vocabulary बन जाता है, कोई नया concept नहीं। जो weak-subject query आपने आज लिखी वह लगभग line for line वही है जैसे result-analysis dashboards failing courses को flag करते हैं।
Summary
Key takeaways
- GROUP BY एक value share करती rows को एक summary row में fold करता है; इसे aggregates के साथ जोड़िए।
- WHERE rows को grouping से PEHLE filter करता है (कोई aggregates नहीं); HAVING groups को BAAD filter करता है (aggregates allowed)।
- ORDER BY sort करता है (ASC default, reverse के लिए DESC), multiple keys allowed।
- CASE WHEN ... THEN ... ELSE ... END = query में if-else; first match जीतता है, WHENs strictest पहले order कीजिए।
- Clause order: SELECT FROM WHERE GROUP BY HAVING ORDER BY LIMIT।
- Memory hook: ढेर, slips, कमज़ोर ढेर फेंकिए, बाक़ी arrange कीजिए।