Theory
વિખરાયેલા Ticket ની સમસ્યા
આપણા TicketDesk database ના schema ને જુઓ. જો એક support manager તમને બધાં સક્રિય tickets નો સોંપાયેલા agent ના નામ સાથેનો જીવંત report છાપવાનું કહે, તમે તરત એક અવરોધનો સામનો કરો છો. tickets table માં માત્ર એક આંકડાકીય agent_id નો અંક છે. એ માણસોનાં ખરેખરાં નામ agents table ની અંદર રહે છે. તમે એક system ના client ને raw ID નંબરો દેખાડી શકતા નથી. તો તમે એક જ query કેવી રીતે લખો જે આ 2 અલગ tables ને પડખોપડખ ચોંટાડી દે?
Theory
વહેંચાયેલા Token નું જોડાણ
એક ઊંચી સુરક્ષાવાળી conference કલ્પો જ્યાં મહેમાનો પાસે સુરક્ષાના token ના ડાબા અડધા ભાગ છે અને યજમાનો પાસે જમણા અડધા ભાગ. ઓળખ ચકાસવા, તમે મળતા અડધા ભાગ સાથે સરકાવો છો. એક inner join માત્ર એ લોકોને જોડે છે જેમની પાસે મળતો સામો ભાગ છે. એક outer join ખાતરી કરે છે કે એક મહેમાન પાસે સોંપાયેલો યજમાન ન હોય (કે એક યજમાન પાસે મહેમાનો ન હોય) તો પણ, એ હજી પણ યાદીમાં આવે, ખૂટતી બાજુ સંપૂર્ણપણે કોરી છોડતાં.
Theory
Join નું કુટુંબ ઔપચારિક રીતે
Oracle SQL માં, એક Join Query 2 કે વધુ tables ના columns ને એમની વચ્ચેના એક સંબંધિત સહિયારા column ના આધારે જોડે છે. એક INNER JOIN માત્ર ત્યારે rows પાછી આપે છે જ્યારે join ની condition બંને tables માં મળે. એક LEFT OUTER JOIN ડાબા table ના બધા records ઉપરાંત જમણા table માંથી મળતા records પાછા આપે છે. એક RIGHT OUTER JOIN બિલકુલ ઊલટું કરે છે. એક FULL OUTER JOIN બંને બાજુના બધા records જાળવે છે, જ્યારે એક CROSS JOIN એક Cartesian product બનાવે છે.
At a glance
ન મળતા data ના records પર SQL join ના પ્રકારોનું વર્તનનું matrix
| Join નો પ્રકાર | મેળવવાની Logic | ન મળતી Rows નું વર્તન |
|---|---|---|
| INNER JOIN | બંને બાજુ કડક મેળ | અંતિમ પરિણામોમાંથી સંપૂર્ણપણે બાકાત |
| LEFT OUTER JOIN | બંને મેળવે છે, બધું ડાબું રાખે છે | જમણી બાજુનાં attributes NULL થી ભરાય છે |
| RIGHT OUTER JOIN | બંને મેળવે છે, બધું જમણું રાખે છે | ડાબી બાજુનાં attributes NULL થી ભરાય છે |
| CROSS JOIN | કોઈ condition આંકાતી નથી | દરેકે દરેક હરોળ બીજા table સાથે ગુણાય છે |
Practical
Writing Explicit ANSI Joins in TicketDesk
-- Query 1: Fetching tickets with their agent names using INNER JOIN
SELECT t.title, a.name
FROM tickets t
INNER JOIN agents a
ON t.agent_id = a.id;
-- Query 2: Left Join to include tickets that have no assigned agent yet
SELECT t.title, a.name
FROM tickets t
LEFT OUTER JOIN agents a
ON t.agent_id = a.id;This example runs in Gri-Learn on the web, where you can edit it and see the output.
Quiz
જો tickets table માં agent_id ની values 10, 20, અને NULL વાળી 3 rows હોય, અને agents table માં IDs 10 અને 20 હોય, તો એક INNER JOIN query કેટલી rows પાછી આપે છે?
- 3 rows
- 2 rows
- 1 હરોળ
- 0 rows
Show the answer
2 rows
એક INNER JOIN બંને બાજુ કડક, સફળ મેળ માંગે છે. NULL agent_id ધરાવતી ticket ની હરોળ agents table માં કંઈ પણ સાથે મળી શકતી નથી, તેથી એ અંતિમ output માંથી સંપૂર્ણપણે કાઢી નખાય છે, બિલકુલ 2 મળતી rows છોડતાં.
Think first
માનસિક ગણતરી: Cross Join નો વિસ્ફોટ
ધારો કે TicketDesk વધીને બિલકુલ 100 tickets અને 5 નોંધાયેલા agents ધરાવે છે. ઉજાગર કરવા click કરતાં પહેલાં મનમાં ગણો કે એક CROSS JOIN query કુલ કેટલી rows બનાવશે.
Show the answer
એ બિલકુલ 500 rows બનાવશે. એક CROSS JOIN પહેલા table ની દરેકે દરેક હરોળને બીજા table ની દરેકે દરેક હરોળ સાથે ગુણે છે (100 × 5 = 500), કોઈ પણ તાર્કિક સંબંધનાં જોડાણો કે મળતી ચાવીઓ સંપૂર્ણપણે અવગણતાં.
Watch out
ખૂટતા ON Clause ની આફત
University ની પરીક્ષાઓમાં marks ગુમાવવાનો સૌથી સામાન્ય રસ્તો છે ON clause કે એની સમકક્ષ WHERE condition ભૂલી જવી. જો તમે મળતી ચાવીની logic નિર્દિષ્ટ કર્યા વગર SELECT * FROM tickets, agents; લખો, Oracle એક અજાણતાં થયેલો CROSS JOIN ચલાવે છે. જો tables માં મોટા datasets હોય તો આ એક વિશાળ data નો વિસ્ફોટ સર્જે છે જે તમારું development નું server crash કરી શકે કે તમારું exam નું lab terminal થીજવી શકે!
Theory
ઉદ્યોગની શ્રેષ્ઠ પ્રથાઓ અને ભવિષ્યનાં Semesters
જૂની Oracle ની legacy systems માં, developers outer joins માટે એક ખાસ (+) operator ની syntax વાપરતા. આવું કરવાનું ટાળો! આધુનિક enterprise software ના વાતાવરણો અને તમારો આવનારો Sem 3 નો SQLite નો અભ્યાસક્રમ સખ્તાઈથી આધુનિક સ્પષ્ટ ANSI standard ના JOIN ... ON ના command શબ્દો વાપરે છે. એ queries ને વાંચી શકાય એવી, જુદી database ની brands પર સાર્વત્રિક રીતે લઈ જઈ શકાય એવી, અને સાફ કરવામાં સહેલી રાખે છે.
Summary
Key takeaways
- SQL Joins સંબંધિત primary અને foreign key ના columns વાપરીને અલગ tables પરનો data જોડે છે.
- INNER JOIN સખ્તાઈથી બાકાત રાખનારો છે, માત્ર ત્યારે પરિણામો પાછાં આપે છે જ્યારે એક સંપૂર્ણ મેળ અસ્તિત્વમાં હોય.
- LEFT અને RIGHT OUTER JOINS ખૂટતી બાજુઓને NULL entries થી ભરીને ન મળતી data ની rows બચાવે છે.
- FULL OUTER JOIN મેળની સફળતાને ધ્યાનમાં લીધા વગર બંને tables ના દરેકે દરેક record જાળવે છે.
- એક મળતી condition છોડી દેવાથી અકસ્માતે CROSS JOIN થાય છે, જે Cartesian product ના ગુણાકારમાં પરિણમે છે.
- Memory hook: Inner મળતી જોડીઓ પસંદ કરે છે, Outer એકલા data ને બચાવે છે, Cross બધાને ગુણે છે!