Theory
નામ એક કોષ્ટકમાં વસે છે, scores બીજામાં
આચાર્ય અત્યાર સુધીનો સૌથી સાદો પ્રશ્ન પૂછે છે: "મને students નાં નામ એમના DBMS ના scores સાથે દેખાડો."
સમસ્યા: નામ students માં વસે છે, scores marks માં વસે છે. એકેય કોષ્ટક એકલું જવાબ આપી શકતું નથી.
Data ને આ રીતે વહેંચવો એ BCA105 નો normalization નો પાઠ પોતાનું કામ કરતો હતો (કોઈ પુનરાવર્તન નહીં). પણ વહેંચાયેલો data query ના સમયે પાછો સીવવો પડે, વહેંચાયેલા roll ના ખાના દ્વારા હરોળ મેળવીને. સીવવાને joining કહેવાય છે, અને joins નું નાનું કુટુંબ છે, દરેક જુદા પ્રશ્નનો જવાબ આપતું.
Theory
Roll number પ્રમાણે બે રજિસ્ટર મેળવવાં
એક રજિસ્ટર પ્રવેશ ની યાદી કરે છે (roll, નામ, શહેર). બીજું પરીક્ષાની નોંધણી ની (roll, વિષય, score).
આચાર્યને જવાબ આપતો કારકુન પ્રવેશના રજિસ્ટરમાં ચાલે છે અને, દરેક roll માટે, પરીક્ષાના રજિસ્ટરમાં મળતી લીટીઓ શોધે છે. મળી: એમને સ્ટેપલ કરો. Join નું કુટુંબ ફક્ત એટલામાં જુદું પડે છે કે જ્યારે roll નો મેળ ન મળે ત્યારે કારકુન શું કરે: એને છોડી દે, ખાલી જગ્યાઓ સાથે રાખે, કે બધાને ગમે એમ જોડી દે.
At a glance
Join નું કુટુંબ એક નજરમાં
| Join | શું રાખે છે | સામાન્ય પ્રશ્ન |
|---|---|---|
| INNER | ફક્ત મળતી જોડી | નામ એમના scores સાથે |
| LEFT | બધી ડાબી હરોળ; ખાલી જગ્યાઓમાં NULL | Marks વગરના students પણ સામેલ કરો |
| CROSS | દરેક જોડી (m × n હરોળ) | દરેક student × દરેક વિષયની જાળી |
| SELF | કોષ્ટક પોતાની સાથે મેળવાયું (aliases) | એક શહેરના students ની જોડી |
| FULL OUTER | બંને બાજુની મેળ ન ખાતી હરોળ | બધું, મળે કે ન મળે |
Practical
કુટુંબ, college.db પર
-- INNER: names with scores (unmatched students vanish)
SELECT s.name, m.subject, m.score
FROM students s
INNER JOIN marks m ON s.roll = m.roll;
-- LEFT: EVERY student, NULL score if they never sat an exam
SELECT s.name, m.score
FROM students s
LEFT JOIN marks m ON s.roll = m.roll;
-- the classic use of LEFT: who has NO marks at all?
SELECT s.name
FROM students s
LEFT JOIN marks m ON s.roll = m.roll
WHERE m.roll IS NULL;
-- CROSS: every student paired with every subject (a blank grid)
SELECT s.name, sub.subject
FROM students s CROSS JOIN subjects sub;
-- SELF: pairs of students from the same city (aliases a, b)
SELECT a.name, b.name, a.city
FROM students a
JOIN students b ON a.city = b.city AND a.roll < b.roll;
This example runs in Gri-Learn on the web, where you can edit it and see the output.
Theory
બે અઘરાં વાંચવાં
SELF JOIN: એક કોષ્ટક, બે aliases (a અને b) હેઠળ બે વાર વપરાયેલું, કારણ કે SQL ને નકલો અલગ પાડવા જુદાં નામ જોઈએ. a.roll < b.roll ની યુક્તિ દરેક જોડીને બે વાર દેખાતી અટકાવે છે અને students ને પોતાની સાથે જોડાતા અટકાવે છે.
FULL OUTER JOIN: બંને બાજુની મેળ ન ખાતી હરોળ રાખે છે. વર્ષો સુધી SQLite માં એ પ્રખ્યાત રીતે નહોતું (પાઠ્યપુસ્તકનો જવાબ: બંને દિશામાં LEFT JOIN કરીને UNION થી અનુકરણ કરો); 2022 થીની આવૃત્તિઓ એને મૂળભૂત રીતે આપે છે. પરીક્ષામાં, બંને હકીકતો કહો અને તમે બંને રીતે સલામત છો.
Quiz
students માં 3 હરોળ છે, marks માં 4 હરોળ છે, અને એક student ને બિલકુલ marks નથી. INNER JOIN અને LEFT JOIN (students LEFT JOIN marks, ON roll) દરેક કેટલી હરોળ આપે છે?
- INNER: 4, LEFT: 5
- INNER: 4, LEFT: 4
- INNER: 3, LEFT: 4
- INNER: 12, LEFT: 12
Show the answer
INNER: 4, LEFT: 5
INNER દરેક મેળ દીઠ એક હરોળ આપે છે: marks ની ચારેય હરોળ કોઈક student સાથે મળે છે, એટલે 4. LEFT એ 4 રાખે છે અને marks વગરના student ને એક વાર NULL સાથે ઉમેરે છે: 5. વિકલ્પ D (12 = 3 × 4) એ છે જે CROSS JOIN બનાવત, કે જ્યારે કોઈ ON ની શરત સાવ ભૂલી જાય ત્યારે થાય છે: એ જ ભૂલ જેની છેલ્લો વિભાગ ચેતવણી આપે છે. હરોળની સંખ્યામાંથી join નું output ગણવું એ પ્રમાણભૂત પરીક્ષાની કસરત છે; મેળે મેળે તર્ક કરો.
Think first
Join પસંદ કરો
ત્રણ માંગણી: (1) હાજરી માટે લાયક યાદી: દરેક student, marks હોય ત્યાં marks સાથે, નહીં તો ખાલી; (2) દરેક student સામે દરેક વિષયની છાપી શકાય એવી કોરી જાળી; (3) roommate ના સૂચનો: એક જ શહેરના students ની જોડી. Tap કરતાં પહેલાં દરેકનું join નામ આપો.
Show the answer
(1) LEFT JOIN: બધી ડાબી હરોળ બચે છે, ખાલી જગ્યાઓ NULL બને છે.
(2) CROSS JOIN: જાણીજોઈને દરેકને દરેક સાથે જોડવું.
(3) બે aliases સાથે શહેર પર SELF JOIN (વત્તા પુનરાવર્તન અને પોતાની સાથેની જોડી ટાળવા a.roll < b.roll).
પસંદગીનું logic: મેળ વગર કોણ બચવું જોઈએ? ડાબી હરોળ → LEFT. દરેકને દરેક સાથે → CROSS. મારી પોતાની બીજી નકલ → SELF.
Watch out
ચૂપ આપત્તિઓ
ON ભૂલવું: શરત વગરનું FROM students JOIN marks CROSS JOIN માં ઢળી પડે છે: હજારો અર્થહીન હરોળ, કોઈ ભૂલનો સંદેશ નહીં.
LEFT જોઈતું હતું ત્યાં INNER: marks વગરનો student ચૂપચાપ અહેવાલોમાંથી અદૃશ્ય થાય છે; એ student ફરિયાદ ન કરે ત્યાં સુધી કોઈને ખબર પડતી નથી. જ્યારે અહેવાલે દરેક નો હિસાબ આપવો પડે, ત્યારે default માં LEFT રાખો અને IS NULL થી ચકાસો.
Theory
Joins એ normalization નું ફળ છે
BCA105 એ તમને data ને સ્વચ્છ કોષ્ટકોમાં વહેંચતાં શીખવ્યું; joins એ વચન અપાયેલું પુનર્મિલન છે. દરેક ખરેખરી system એમના પર ચાલે છે: તમારું college નું portal students ને ફી અને છાત્રાલય સાથે જોડે છે, Grishu વિષયોને તમારા quiz ના પ્રયાસો સાથે જોડે છે. એકમ 4 માં, pandas એ જ યુક્તિ pd.merge(students, marks, on='roll', how='left') તરીકે કરે છે: how= નું parameter શબ્દશઃ આ પાઠનું કોષ્ટક છે.
Summary
Key takeaways
- Joins બે કોષ્ટકોને મળતા ખાના પર સીવે છે: FROM a JOIN b ON a.key = b.key.
- INNER ફક્ત મળતાં રાખે છે; LEFT ડાબી દરેક હરોળ ખાલી જગ્યાઓમાં NULL સાથે રાખે છે.
- LEFT વત્તા WHERE right.key IS NULL એ મેળ વગરની ડાબી હરોળ શોધે છે (marks વગરનો student).
- CROSS બધાને બધા સાથે જોડે છે (m × n); ભૂલાયેલું ON એ જ આપત્તિ આપે છે.
- SELF કોષ્ટકને બે aliases દ્વારા પોતાની સાથે જોડે છે; a.roll < b.roll પુનરાવર્તન મારે છે.
- FULL OUTER: બંને બાજુથી મેળ વગરનું; SQLite માં પરંપરાગત રીતે અનુકરણ કરાતું, 2022 થી મૂળભૂત.
- Memory hook: મેળ ન ખાતા roll નું કારકુન શું કરે છે?