Theory
વેરાયેલા Data નો કોયડો
તમારા college ના આચાર્ય બધા library members ની યાદી માંગે છે સાથે એ ચોક્કસ તારીખો પણ જ્યારે એમણે પુસ્તકો લીધાં. તમે CampusLib database પર દોડો છો અને tables તપાસો છો. members table માં નામ છે પણ issue ની તારીખો નથી. issues table માં તારીખો છે પણ નામ નથી, માત્ર member_id નંબરો. તમને જોઈતો data અલગ સંરચનાત્મક ટાપુઓ પર ફસાયેલો છે. તમારી university ની પરીક્ષા અને વાસ્તવિક database ડિઝાઇન માટે આ ઉકેલવા, તમારે Joins વાપરીને tables ને એકબીજામાં ભેળવવાની કળા પર પ્રભુત્વ મેળવવું પડશે.
Theory
વહેંચાયેલો Token નો ચોપડો
એક college ના ઉત્સવમાં token counter ને વિચારો. એક પહોંચની ચોપડી તમારું નામ Token Number 105 સાથે સંઘરે છે. એક અલગ રસોડાનો ચોપડો નોંધે છે કે Token Number 105 એ સમોસાની થાળી લીધી. કોણે શું ખાધું એ સમજવા, આયોજક બંને કાગળ પરના token numbers મેળવે છે. SQL Joins બિલકુલ આ જ કરે છે: એ member_id જેવો એક સહિયારો column વાપરીને બે tables ને કામચલાઉ રીતે એક જ અર્થપૂર્ણ spreadsheet માં પાછાં સીવી દે છે.
Theory
Tables ને ઔપચારિક રીતે ભેળવવાં
Relational databases માં, એક Join Query એ એવી કામગીરી છે જે બે કે વધુ tables માંથી rows ને એમની વચ્ચેના એક સંબંધિત column ના આધારે જોડે છે. જ્યારે normalization બિનજરૂરી પુનરાવર્તન ટાળવા data ને વહેંચે છે, ત્યારે joins execution દરમિયાન એને પાછો જોડે છે. Oracle SQL માં, ન મળતી rows સાથે કેવો વ્યવહાર થાય એ નિયંત્રિત કરવા આપણે FROM clause ની અંદર સ્પષ્ટ relational keywords વાપરીએ છીએ. મુખ્ય કુટુંબમાં Inner Joins, Outer Joins, અને Cross Joins છે.
At a glance
Relational database systems માં મુખ્ય join કામગીરીઓ
| Join નો પ્રકાર | એ શું પાછું આપે છે | ન મળતી Rows સાથેનો વ્યવહાર |
|---|---|---|
| INNER JOIN | માત્ર એ rows જેમની values બંને tables માં મળે છે | Output ના દૃશ્યમાંથી સંપૂર્ણપણે કાઢી નખાય છે |
| LEFT OUTER JOIN | ડાબા table ની બધી rows, ઉપરાંત જમણા table માંથી મળતી rows | ન મળતા જમણા columns NULL થી ભરાય છે |
| RIGHT OUTER JOIN | જમણા table ની બધી rows, ઉપરાંત ડાબા table માંથી મળતી rows | ન મળતા ડાબા columns NULL થી ભરાય છે |
| FULL OUTER JOIN | બંને tables ના બધા records સાથે જોડાયેલા | ખૂટતું હોય તો કોઈ પણ બાજુ કોરી જગ્યાઓ NULL થી ભરે છે |
Practical
Stitching Members and Issues in Oracle SQL
-- Query 1: Inner Join shows only members who currently have active issues
SELECT m.name, i.issue_date
FROM members m
INNER JOIN issues i ON m.member_id = i.member_id;
-- Query 2: Left Join preserves all members, even those who never borrowed a book
SELECT m.name, NVL(i.issue_date, 'No Books Issued') AS status
FROM members m
LEFT OUTER JOIN issues i ON m.member_id = i.member_id;Quiz
જો તમારા CampusLib ના members table માં 5 student records હોય અને એમાંથી માત્ર 3 એ ખરેખર પુસ્તકો લીધાં હોય, તો members થી issues સુધીનું એક LEFT OUTER JOIN student ની યાદી માટે કેટલી rows પાછી આપશે?
- બિલકુલ 3 rows કારણ કે માત્ર 3 મેળ અસ્તિત્વમાં છે.
- બિલકુલ 5 rows કારણ કે ડાબા table નું માળખું બધા મૂળ members જાળવે છે.
- Matrix ગુણાકારની વ્યવસ્થાને કારણે બિલકુલ 15 rows.
- 0 rows કારણ કે NULL values statement નું execution અમાન્ય કરે છે.
Show the answer
બિલકુલ 5 rows કારણ કે ડાબા table નું માળખું બધા મૂળ members જાળવે છે.
એક LEFT OUTER JOIN ખાતરી આપે છે કે ડાબા table (members) ની દરેકે દરેક હરોળ અંતિમ પરિણામમાં રહે. જે 2 students એ ક્યારેય પુસ્તકો લીધાં નથી એમને કાઢી નાખવાને બદલે Oracle એમની issue ની વિગતો NULL values થી ભરી દે છે. એક INNER JOIN માત્ર 3 rows પાછી આપત.
Watch out
Cross Join ની આફત
એક university SQL exam માં marks ગુમાવવાનો સૌથી ઝડપી રસ્તો છે ON keyword કે conditional clause છોડી દેવો. મળતા filter વગર SELECT * FROM members, issues; લખવાથી એક Cross Join, કે Cartesian Product, trigger થાય છે. જો CampusLib માં 1,000 members અને 5,000 issue logs હોય, Oracle દરેક member ને દરેકે દરેક log સાથે ગુણે છે, 5,000,000 ગૂંચવનારી rows બનાવતાં. આ server ની performance સંપૂર્ણપણે તોડી નાખે છે.
Think first
Dialect ચકાસણીનો પડકાર
માનસિક પડકાર: જો તમે તમારો Oracle code સીધો તમારા Semester 3 ના lab માટે એક જૂના SQLite database માં નકલ કરો, તો FULL OUTER JOIN ધરાવતી query બરાબર ચાલશે? Tap કરતાં પહેલાં મનમાં syntax ના નિયમો તપાસો.
Show the answer
ના, એ એક syntax error ફેંકશે! Oracle SQL FULL OUTER JOIN keyword ને શરૂઆતથી જ પૂરેપૂરું support કરે છે. પણ, પાયાનાં SQLite environments FULL OUTER JOIN ને મૂળભૂત રીતે support કરતાં નથી. SQLite માં એ જ output મેળવવા, તમારે એક UNION operator વાપરીને એક LEFT JOIN અને એક RIGHT JOIN જોડવાં પડશે. હંમેશા તમારા SQL dialect ના લક્ષ્યો તપાસો!
Theory
Oracle NVL નો ફાયદો
એક LEFT OUTER JOIN વાપરીને વાસ્તવિક management ના reports બનાવતી વખતે, ખાલી fields કોરી જગ્યાઓ (NULL) તરીકે પાછાં આવે છે. તમે Oracle ના મૂળ NVL() function વાપરીને આ કોરી જગ્યાઓને વાંચી શકાય એવી strings થી બદલી શકો છો, એક કદરૂપા ખાલી cell ને એક વ્યાવસાયિક 'No History Found' સૂચનામાં ફેરવતાં.
Summary
Key takeaways
- Joins relational conditions વાપરીને અલગ normalized tables પરના records જોડે છે.
- એક INNER JOIN સંપૂર્ણ value ની સમાનતા માંગે છે, સ્પષ્ટ મેળ વગરના કોઈ પણ records બાકાત રાખતાં.
- Outer joins ખાલી જગ્યાઓ માટે NULL entries બનાવીને અસંતુલિત data tables જાળવે છે.
- ખૂટતું join clause એક Cross Join પર મજબૂર કરે છે જે અકસ્માતે એક Cartesian product ઊભું કરે છે.
- Oracle SQL FULL OUTER JOIN ની syntax ને મૂળભૂત રીતે support કરે છે, જ્યારે SQLite ને નકલી ઉપાયો જોઈએ છે.
- Memory hook: Inner joins સંપૂર્ણ મેળ માંગે છે, પણ Outer joins કોઈ table ને પાછળ છોડતાં નથી!