Theory
પુસ્તકકીડાઓનું રહસ્ય
તમારા HOD આપણા CampusLib database માંનું સૌથી મોંઘું પુસ્તક લેનાર student ને એક ખાસ પ્રમાણપત્ર આપવા માંગે છે. તમે તમારાં tables જુઓ છો. members table students નાં નામ જાણે છે, પણ પુસ્તકોની કિંમતો વિશે કંઈ નહીં. books table કિંમતો જાણે છે, પણ કોણે એ લીધાં એ વિશે કંઈ નહીં. તમે એક સાદું filter લખી શકતા નથી કારણ કે તમને પહેલેથી મહત્તમ કિંમત ખબર નથી. તો તમે એવી સમસ્યા કેવી રીતે ઉકેલો જ્યાં filter ની value જ તમે એને શોધો નહીં ત્યાં સુધી પૂરું રહસ્ય હોય?
Theory
આચાર્યની પૂછપરછની કચેરી
કલ્પો કે તમારા college ના આચાર્ય કહે છે, 'સૌથી ઓછી હાજરી વાળા વર્ગના class representative ને બોલાવો.' આ પાળવા, તમારે પહેલાં હાજરીના મેજ પર જવું પડશે, જોવું પડશે કે કયા વર્ગની હાજરી સૌથી ઓછી છે (ધારો કે Section B), અને પછી Section B પર જઈને એમનો પ્રતિનિધિ શોધવો પડશે. તમે મનમાં બે queries ચલાવી! પહેલી query એ જવાબ શોધ્યો જે બીજી query ને કામ પૂરું કરવા જોઈતો હતો. આ query-ની-અંદર-query નું માળખું એટલે એક nested query.
Theory
Nested Query શું છે?
એક Nested Query, જેને subquery પણ કહેવાય છે, એ એક બહારની query ના WHERE કે HAVING clause ની અંદર જડેલું એક અંદરનું SELECT statement છે. Oracle SQL માં, સ્વતંત્ર અંદરની query બહારની મુખ્ય query ચાલે એ પહેલાં બિલકુલ એક જ વાર ચાલે છે. આ અંદરના execution નું પરિણામ સીધું બહારની query ના filter clause માં મુકાય છે. આ તમને એવી ગતિશીલ શોધો લખવા દે છે જે તમારાં database tables સમય જતાં update કે વિસ્તરે તેમ ગોઠવાઈ જાય.
At a glance
અંદરની query ના output ના સ્વરૂપના આધારે subqueries નું વર્ગીકરણ
| Subquery નો પ્રકાર | જરૂરી Operator | અપેક્ષિત આંતરિક પરિણામ |
|---|---|---|
| Single-Row Subquery | =, >, <, >=, <= | એક જ કિંમતના cell જેવી બિલકુલ એક scalar value પાછી આપે છે |
| Multi-Row Subquery | IN, ANY, ALL | એક column માંથી અનેક values ની એક ઊભી યાદી પાછી આપે છે |
| Multi-Column Subquery | IN | સંરચનાત્મક જોડ કે tuples સાથે મળતા અનેક columns પાછા આપે છે |
Practical
Finding Members with the Most Expensive Book
-- Step 1: Find the max price from books
-- Step 2: Use that price to find matching book IDs
-- Step 3: Match those book IDs to member IDs in issues
SELECT name
FROM members
WHERE member_id IN (
SELECT member_id
FROM issues
WHERE book_id IN (
SELECT book_id
FROM books
WHERE price = (SELECT MAX(price) FROM books)
)
);This example runs in Gri-Learn on the web, where you can edit it and see the output.
Follow along
સૌથી-અંદરથી-પહેલાં વાંચવાની ટેવ
- 1. સૌથી અંદરની Query ચલાવો Oracle MAX(price) દ્વારા સૌથી ઊંચી આંકડાકીય value ગણવા સૌથી ઊંડી subquery પહેલાં આંકે છે.
- 2. Values ઉપર મોકલો પરિણામી value અંદરના કૌંસને બદલી નાખે છે, પુસ્તકના filter માં ભળતાં.
- 3. વચલી Query આંકો મુખ્ય query એ value સાથે મળતા પુસ્તકના codes શોધે છે અને IDs નો એક સંગ્રહ પાછો આપે છે.
- 4. અંતિમ બહારની Query ચલાવો સૌથી બહારનું SELECT એ IDs ને member ની profiles સામે મેળવે છે અને અંતિમ students નાં નામ છાપે છે.
Quiz
જો તમે બરાબરના operator (=) વાપરીને એક nested query લખો પણ અંદરની query ને અકસ્માતે એ જ મહત્તમ કિંમત ધરાવતાં બે જુદાં પુસ્તકો મળે, તો Oracle SQL શું કરશે?
- એ આપોઆપ પહેલી મળતી હરોળ પસંદ કરશે અને બીજી હરોળ ચૂપચાપ અવગણશે.
- એ એક runtime error ફેંકશે કારણ કે એક single-row operator અનેક rows મેળવી શકતો નથી.
- એ સફળતાપૂર્વક પોતાનો mode બદલશે અને કોઈ ફરિયાદ વગર બંને મળતા records પાછા આપશે.
- એ આખો database connection pool crash કરશે અને ભૌતિક table નો સંગ્રહ બગાડી નાખશે.
Show the answer
એ એક runtime error ફેંકશે કારણ કે એક single-row operator અનેક rows મેળવી શકતો નથી.
બરાબર (=) કે એથી-નાનું (<) જેવા single-row comparison operators વાપરવાથી માંગ થાય છે કે subquery બિલકુલ એક જ value પાછી આપે. જો એ અનેક records પાછા આપે, Oracle એક સ્પષ્ટ error ના નિશાન સાથે અટકી જાય છે. શક્ય multi-row outputs સલામત રીતે સંભાળવા, તમારે operator બદલીને IN કરવો પડશે.
Watch out
Correlated Performance નો ખાડો
Correlated Subqueries સાથે અત્યંત સાવધ રહો! માત્ર એક જ વાર ચાલતી standard nested queries થી વિપરીત, એક correlated subquery બહારના table માંથી આવતા એક column નો સંદર્ભ લે છે. આ Oracle ને બહારના table માં હાજર દરેકે દરેક હરોળ માટે આખો અંદરનો query block ફરીથી ચલાવવા મજબૂર કરે છે! જો તમારા members table માં 10,000 students હોય, અંદરની શોધ 10,000 વાર ચાલે છે, એક વિશાળ processing નો અવરોધ ઊભો કરતાં જે તમને university lab exams માં marks ગુમાવશે.
Think first
Select List Subquery નો પડકાર
માનસિક પડકાર: આ ગોઠવણ તપાસો: 'SELECT name, (SELECT MAX(price) FROM books) FROM members;'. શું આ માળખું Oracle SQL માં સફળતાપૂર્વક ચાલશે, કે એ એક અમાન્ય statement છે? Tap કરતાં પહેલાં મનમાં માળખાકીય ગોઠવણ તપાસો.
Show the answer
એ બરાબર ચાલશે! આને Scalar Subquery તરીકે ઓળખાય છે. Oracle SQL માં, તમે એક nested query ને સીધી column ની પસંદગીની યાદીની અંદર મૂકી શકો છો, શરત એ કે એ એક જ મૂલ્યાંકનની value ની ખાતરી આપે. એ દરેક અલગ member ના record ની હરોળ સાથે પડખેપડખ પુસ્તકની વૈશ્વિક મહત્તમ કિંમત દેખાડશે.
Theory
Dialect ના ભેદ અને Career Tracking
જ્યારે subqueries Semester 3 માંના SQLite જેવા dialects પર સુસંગત રીતે વર્તે છે, ત્યારે Oracle SQL માં માલિકીનાં optimization engines છે જે પડદા પાછળ nested subqueries ને સપાટ કરેલા આંતરિક semi-joins માં ફેરવે છે. આ સૌથી-અંદરથી-પહેલાં વાંચવાની માનસિકતા કેળવવી તમને શ્રેષ્ઠ code લખવા અને તાંત્રિક campus placements દરમિયાન backend data architecture ના રાઉન્ડ પાર કરવા તૈયાર કરે છે!
Summary
Key takeaways
- એક nested query એક બહારના filter expression ની અંદર એક ગૌણ SELECT statement અલગ પાડે છે.
- Oracle બિન-correlated subqueries ને અંદરથી બહાર process કરે છે, સૌથી ઊંડો block પહેલાં પૂરો કરતાં.
- Single-row comparison operators અંદરની nested પસંદગીમાંથી બિલકુલ એક જ value માંગે છે.
- Multi-row પરિણામોને errors ટાળવા IN, ANY, કે ALL જેવા ખાસ operators વાપરીને filter કરવાં જ પડે.
- Correlated subqueries બહારની query ના columns નો સંદર્ભ લે છે અને દરેક હરોળ માટે વારંવાર આંકાય છે.
- Memory hook: અંદરથી બહાર વિચારો, મુખ્ય રસ્તો સાફ કરતાં પહેલાં અંદરની ઉખાણી ઉકેલો!