Theory
આચાર્યને દરેક વિષય દીઠ એક લીટી જોઈએ છે
ResultDesk ની આગલી માંગણી સાદી લાગે છે: "દરેક વિષયનો સરેરાશ score, સૌથી ખરાબ પહેલાં, અને 50 થી નીચે સરેરાશવાળા વિષયો ઉજાગર કરો."
તમને BCA105 થી AVG આવડે છે, પણ આખા marks ના કોષ્ટક પરની AVG આખી college માટે એક સંખ્યા આપે છે. આચાર્યને દરેક વિષય દીઠ એક લીટી જોઈએ છે: DBMS 61.5, Maths 73.2, ...
તમને હજારો હરોળને દરેક જૂથ દીઠ એક સારાંશની હરોળ માં વાળવાની રીત જોઈએ, પછી એ સારાંશો ગાળવા અને ક્રમમાં ગોઠવવા. એ જ GROUP BY ની ઓજારપેટી છે.
Theory
ઉત્તરવહીઓને ઢગલામાં ગોઠવવી
દરેક ઉત્તરવહી મેજ પર ઠાલવો: અંધાધૂંધી. હવે દરેક વિષય દીઠ એક ઢગલો બનાવો, અને દરેક ઢગલા દીઠ એક ચિઠ્ઠી લખો: ઢગલાનું નામ, સરેરાશ, ગણતરી.
GROUP BY ઢગલા બનાવે છે. Aggregates દરેક ઢગલાની ચિઠ્ઠી લખે છે. HAVING કસોટીમાં નિષ્ફળ જતા આખા ઢગલા ફેંકી દે છે (50 થી નીચે સરેરાશ). ORDER BY બચેલી ચિઠ્ઠીઓ વાંચવા માટે ગોઠવે છે. ઢગલા બન્યા પછી તમે વ્યક્તિગત ઉત્તરવહી ક્યારેય જોતા નથી: ફક્ત ચિઠ્ઠીઓ.
Theory
GROUP BY અને HAVING, ઔપચારિક રીતે
GROUP BY col એ col નું એક જ મૂલ્ય વહેંચતી બધી હરોળને એક output ની હરોળ માં ભેગી કરે છે; પસંદ કરેલું બીજું દરેક ખાનું aggregate માં વીંટાળેલું હોવું જોઈએ.
HAVING aggregation પછી જૂથો ગાળે છે, અને એ એકમાત્ર જગ્યા છે જ્યાં શરતમાં aggregate આવી શકે.
પરીક્ષાઓ જે ભેદ પૂછવાનું ક્યારેય બંધ કરતી નથી:
- WHERE: હરોળ ગાળે છે, જૂથ બનતાં પહેલાં ચાલે છે, aggregates મનાઈ.
- HAVING: જૂથો ગાળે છે, જૂથ બન્યા પછી ચાલે છે, aggregates મંજૂર.
Practical
આચાર્યની માંગણી, એક 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, અંતિમ ઓજારો
ORDER BY average ASC output ને ક્રમમાં ગોઠવે છે: ASC (નાનાથી મોટા) એ default છે, DESC ઊલટાવે છે. અનેક ચાવીઓ ચાલે છે: ORDER BY subject ASC, score DESC.
CASE એ SQL ની if-else ની અભિવ્યક્તિ છે:
CASE WHEN કસોટી THEN મૂલ્ય WHEN કસોટી THEN મૂલ્ય ELSE મૂલ્ય END
શરતો ઉપરથી નીચે તપાસાય છે, પહેલી મળે એ જીતે: score 85 એ >= 70 ની શાખા પકડે છે અને ક્યારેય >= 40 સુધી પહોંચતો નથી. તમારા WHEN ને સૌથી કડકથી સૌથી ઢીલા ક્રમમાં ગોઠવો નહીં તો દરેક હરોળ પહેલી ઢીલી શાખામાં પડે છે.
Quiz
એક student લખે છે: SELECT subject, AVG(score) FROM marks WHERE AVG(score) < 50 GROUP BY subject; અને ભૂલ મળે છે. કેમ?
- WHERE માં aggregates આવી શકતાં નથી; જૂથની શરતો GROUP BY પછી HAVING માં આવે છે
- AVG ને GROUP BY સાથે વાપરી શકાતું નથી
- WHERE હંમેશા GROUP BY પછી આવવું જોઈએ
- Query માં ORDER BY ખૂટે છે
Show the answer
WHERE માં aggregates આવી શકતાં નથી; જૂથની શરતો GROUP BY પછી HAVING માં આવે છે
WHERE ઢગલા બને એ પહેલાં ચાલે છે, જ્યારે AVG(score) હજી અસ્તિત્વમાં જ નથી, એટલે ત્યાં aggregates મનાઈ છે. ઉકેલ: શરતને GROUP BY પછી HAVING AVG(score) < 50 માં ખસેડો. વિકલ્પ B ઊલટો છે (GROUP BY સાથે AVG એ પ્રમાણભૂત જોડી છે), વિકલ્પ C નિશ્ચિત clause ના ક્રમને તોડે છે (WHERE એ GROUP BY પહેલાં આવે છે), અને ORDER BY એ મરજિયાત ઓપ છે, આ ભૂલનું કારણ ક્યારેય નહીં.
Think first
Grade ના પટ્ટા ટ્રેસ કરો
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 (બંને કસોટીમાં નિષ્ફળ, ELSE સુધી પડે છે). 70 → Distinction (>= 70 એ 70 પર સાચું છે; પહેલી મળે એ જીતે અને મૂલ્યાંકન અટકે છે).
બે નિર્ણાયક કિસ્સા છે સીમા (70 એ Distinction ગણાય કારણ કે >= સમાનતા સામેલ કરે છે) અને નીચે પડવું (38 ELSE સુધી પહોંચે છે). પરીક્ષાઓ બરાબર આ બે હરોળ પર આખા પ્રશ્નો બાંધે છે.
Watch out
Clause નો ક્રમ બાંધછોડ વગરનો છે
SELECT ... FROM ... WHERE ... GROUP BY ... HAVING ... ORDER BY ... LIMIT
બીજા કોઈ ક્રમમાં લખો અને SQLite ભૂલ આપે છે. ક્રમને પ્રવાહથી જ યાદ રાખો: હરોળ ગાળો (WHERE), ઢગલા બનાવો (GROUP BY), ઢગલા ગાળો (HAVING), ચિઠ્ઠીઓ ગોઠવો (ORDER BY), ટોચની થોડી લો (LIMIT). અને CASE માં, સૌથી કડક WHEN પહેલું મૂકો: શરતો ઉપરથી નીચે ચકાસાય છે.
Theory
આ ફરી ક્યાં દેખાય છે
એકમ 4 આ જ પાઠ pandas માં ફરી ભજવે છે: GROUP BY એ df.groupby('subject') બને છે, HAVING એ જૂથ પામેલા પરિણામ પર ગાળણ બને છે, CASE એ mapping નું function બને છે. SQL ની આવૃત્તિ પાકી શીખો અને pandas ની આવૃત્તિ નવો ખ્યાલ નહીં, ફક્ત શબ્દભંડોળ બની જાય છે. તમે આજે લખેલી નબળા વિષયની query લગભગ લીટીએ લીટી એ જ છે જે રીતે પરિણામના વિશ્લેષણનાં dashboards નિષ્ફળ જતા courses ઉજાગર કરે છે.
Summary
Key takeaways
- GROUP BY એક જ મૂલ્ય વહેંચતી હરોળને એક સારાંશની હરોળમાં વાળે છે; એને aggregates સાથે જોડો.
- WHERE જૂથ બનતાં પહેલાં હરોળ ગાળે છે (aggregates નહીં); HAVING પછી જૂથો ગાળે છે (aggregates મંજૂર).
- ORDER BY ક્રમમાં ગોઠવે છે (ASC default, ઊલટાવવા DESC), અનેક ચાવીઓ મંજૂર.
- CASE WHEN ... THEN ... ELSE ... END = query માં if-else; પહેલી મળે એ જીતે, WHEN ને સૌથી કડક પહેલાં ગોઠવો.
- Clause નો ક્રમ: SELECT FROM WHERE GROUP BY HAVING ORDER BY LIMIT.
- Memory hook: ઢગલા, ચિઠ્ઠીઓ, નબળા ઢગલા ફેંકો, બાકીના ગોઠવો.