Theory
એક અજાણ્યા રહસ્યના આધારે Record કેવી રીતે શોધો?
કલ્પો કે એક manager તમને આપણી TicketDesk system માં એ બધાં helpdesk tickets શોધવાનું કહે છે જે 'Server Crash' નામના ticket પછી ઊભાં થયાં. તમને 'Server Crash' ક્યારે થયું એની બિલકુલ તારીખ ખબર નથી. એક standard database query માં, તમારે એ crash ની તારીખ શોધવા એક query ચલાવવી પડે, એ ઉતારી લેવી પડે, અને એ તારીખ વાપરીને બીજી query લખવી પડે. આ હાથે કરવાનો અભિગમ આપોઆપ ચાલતી production ની systems અને university ની પરીક્ષાઓમાં સંપૂર્ણપણે નિષ્ફળ જાય છે. તો તમે એક query ને તારીખ શોધીને એ તરત બીજી query માં આપતી કેવી રીતે બનાવો?
Theory
ખોખાની અંદરના ખોખાની શોધ
એક nested query ને એક કોયડાના ખોખા જેવી વિચારો જ્યાં બહારનો પટારો ખોલવાની ચાવી એક નાના અંદરના ખોખામાં છુપાયેલી છે. તમે પહેલાં અંદરનું ખોખું તોડીને ચાવી ન કાઢો ત્યાં સુધી બહારનો પટારો ખોલી શકતા નથી. SQL માં, database engine પહેલાં અંદરની query ઉકેલે છે, એક value કે values ની યાદી કાઢે છે, અને પછી એ તાજી માહિતીને એક અચળ value તરીકે વાપરીને બહારની query filter કરીને આપોઆપ ચલાવે છે.
Theory
Nested Queries ની ઔપચારિક વ્યાખ્યા
Oracle ના dialect માં, એક nested query એ એક બહારની query ના WHERE કે HAVING clause ની અંદર લખાયેલું એક SELECT statement છે. અંદરની query પહેલાં ચાલે છે અને પોતાનાં પરિણામો બહારની query ને આપે છે. Nested queries ને single-row subqueries માં વર્ગીકૃત કરાય છે, જે બિલકુલ એક value પાછી આપે છે અને =, >, કે < જેવા operators વાપરે છે, અને multi-row subqueries માં, જે values નો એક column પાછો આપે છે અને સંરચનાત્મક mismatches અટકાવવા IN, ANY, કે ALL જેવા operators માંગે છે.
At a glance
અંદરની query ના outputs અને મળતા operators ના આધારે Oracle nested queries નું વર્ગીકરણ
| Query નો પ્રકાર | પાછી અપાતી Rows | માન્ય Operators | TicketDesk નો દાખલો |
|---|---|---|---|
| Single-Row | બિલકુલ 1 હરોળ અને 1 column | =, >, <, != | એક જાણીતા ticket ની તારીખ પછી ઊભાં થયેલાં tickets શોધવાં |
| Multi-Row | અનેક rows અને 1 column | IN, ANY, ALL | સક્રિય agents ની એક ચોક્કસ યાદીને સોંપાયેલાં tickets શોધવાં |
| Correlated | બહારના loop ની rows પર આધાર રાખે છે | EXISTS, NOT EXISTS | Critical status વાળું ઓછામાં ઓછું એક ticket સંભાળતા agents શોધવા |
Practical
Writing Single-Row and Multi-Row Nested Queries
-- Step 1: Single-row nested query to find tickets raised after 'Server Crash'
SELECT id, title, raised_on
FROM tickets
WHERE raised_on > (SELECT raised_on FROM tickets WHERE title = 'Server Crash');
-- Step 2: Multi-row nested query to find tickets assigned to specific agents
SELECT title, priority
FROM tickets
WHERE agent_id IN (SELECT id FROM agents WHERE name LIKE 'Amit%');This example runs in Gri-Learn on the web, where you can edit it and see the output.
Quiz
જો એક બહારની query '=' operator વાપરે, પણ અંદરની nested query એકથી વધુ હરોળ પાછી આપે તો શું થશે?
- Oracle આપોઆપ પહેલી હરોળ પસંદ કરશે અને બાકીની અવગણશે
- Oracle એક runtime error ફેંકશે કારણ કે એક single-row operator અનેક values સરખાવી શકતો નથી
- બહારની query ચાલશે પણ સલામતીના પગલા તરીકે શૂન્ય rows પાછી આપશે
- Oracle પડદા પાછળ '=' operator ને dynamically 'IN' માં બદલી નાખશે
Show the answer
Oracle એક runtime error ફેંકશે કારણ કે એક single-row operator અનેક values સરખાવી શકતો નથી
જ્યારે તમે = જેવો એક single-row comparison operator વાપરો, Oracle બિલકુલ એક value ની અપેક્ષા રાખે છે. જો અંદરની nested query અનેક rows પાછી આપે, Oracle ને એક mismatch મળે છે અને એ પ્રખ્યાત ORA-01427 error ફેંકે છે: single-row subquery returns more than one row. અનેક rows સંભાળવા, તમારે IN જેવો multi-row operator વાપરવો જ પડશે.
Think first
માનસિક પડકાર: સરેરાશથી ઉપરનાં Tickets શોધવાં
મનમાં એક nested query લખો જે tickets table માંથી એ બધાં tickets ના id અને title શોધે જેમનું priority નું સ્તર કે આંકડાકીય rating બધાં tickets ના સરેરાશ rating કરતાં ઊંચું હોય. ઉજાગર કરવા tap કરતાં પહેલાં તમને કયું aggregate function જોઈએ એ વિચારો.
Show the answer
Query છે: SELECT id, title FROM tickets WHERE priority_level > (SELECT AVG(priority_level) FROM tickets); અંદરની query પહેલાં એક જ સરેરાશ value ગણે છે, અને પછી બહારની query દરેક અલગ હરોળને એ સરેરાશના પરિણામ સામે સરખાવે છે.
Watch out
Column ની ગણતરીના Mismatch નો ફાંદો
University ની પરીક્ષાઓમાં marks ગુમાવતી એક સામાન્ય ભૂલ છે અંદરની query માં અનેક columns પસંદ કરવા જ્યારે બહારની query માત્ર એકની અપેક્ષા રાખતી હોય. ઉદાહરણ તરીકે, WHERE agent_id IN (SELECT id, name FROM agents) લખવું. Oracle આને એક syntax error સાથે નકારી કાઢશે કારણ કે એ એક જ ID ના column ને બે-column ના પરિણામ સામે સરખાવી શકતું નથી. ખાતરી કરો કે તમારી અંદરની query બિલકુલ એક column પસંદ કરે જે બહારના column ના datatype સાથે મળે.
Theory
વાસ્તવિક દુનિયાનો ઉપયોગ અને ભવિષ્યનાં Semesters
જટિલ reports બનાવતી વખતે કે AI ના dashboards માટે backend ની logic સંભાળતી વખતે nested queries અત્યંત મહત્ત્વની છે. તમારા frontend ના code માં data લાવીને ધીમા loops ચલાવવાને બદલે, એક nested query મહત્તમ કાર્યક્ષમતા માટે સંપૂર્ણપણે database ના server પર ચાલે છે. તમારા Sem 3 ના SQLite ના અભ્યાસક્રમમાં, તમે ભારે boilerplate code લખ્યા વગર mobile applications ની અંદર સ્થાનિક data filter કરવા બિલકુલ આ જ nested query નાં માળખાં વાપરશો.
Summary
Key takeaways
- એક nested query એ બીજી query ના WHERE કે HAVING clause ની અંદર મુકાયેલું એક SELECT statement છે.
- અંદરની query પહેલાં ચાલે છે, અને એનું output બહારની query filter કરવાની મર્યાદા તરીકે વાપરે છે.
- Single-row nested queries એક value પાછી આપે છે અને = કે > જેવા એક-value ના operators માંગે છે.
- Multi-row nested queries અનેક records પાછા આપે છે અને IN, ANY, કે ALL જેવા યાદીના operators માંગે છે.
- સંરચનાત્મક column ના mismatch ની errors ટાળવા અંદરની queries એ બિલકુલ એક column પાછો આપવો જ પડે.
- Memory hook: અંદરની query રહસ્ય ઉજાગર કરે છે, બહારની query અંતિમ પરિણામ આપે છે!