Theory
સમજદાર Fine નું Update
કલ્પો કે college ના આચાર્ય તમને હુકમ કરે છે કે library માંના દરેક એવા પુસ્તકની કિંમત બમણી કરો જે એક પણ student એ ક્યારેય લીધું નથી. તમે તમારું SQL editor ખોલો છો. તમને એક નિશ્ચિત પુસ્તકનો ઓળખ નંબર update કરતાં આવડે છે, પણ તમે એક તદ્દન અલગ table માં છુપાયેલા data ના આધારે એક પુસ્તક કેવી રીતે update કરો? જો હજારો records હોય તો હાથે IDs ની યાદી hardcode કરવી અશક્ય છે. તો આપણે આપણા data ના ફેરફારોને એટલા સમજદાર કેવી રીતે બનાવીએ કે એ પહેલાં database વાંચે?
Theory
ગુપ્તચરની Briefing
એક વહીવટી કારકુનને વિચારો જેને અમુક student profiles પર 'Suspended' નો થપ્પો મારવાનું કામ સોંપાયું છે. અટકળ કરવાને બદલે, કારકુનને hostel ના વોર્ડન પાસેથી એક અલગ યાદી મળે છે જેમાં મિલકતને નુકસાન કરનારા students નાં નામ છે. કારકુન વોર્ડનની યાદી (subquery) જુએ છે અને એને વાપરીને મુખ્ય નોંધણી (મુખ્ય command) update કરે છે. Data નો ફેરફાર સંપૂર્ણપણે અંદરની યાદીએ આપેલા જીવંત જવાબો પર આધાર રાખે છે.
Theory
Subqueries સાથે DML Statements
ઔપચારિક રીતે, એક Subquery with DML એક SELECT statement ને એક INSERT, UPDATE, કે DELETE statement ની અંદર જડે છે. તમારા values, set, કે where clauses માં hardcode કરેલી શાબ્દિક values વાપરવાને બદલે, મુખ્ય statement અંદરની query એ પાછાં આપેલાં ગતિશીલ પરિણામોના આધારે પોતાનો data નો ફેરફાર કરે છે. Oracle SQL માં, આ તમને એક table ના records ને બીજા સંબંધિત table માં મળેલા માપદંડ, સરવાળા, કે યાદીઓના આધારે બદલવા દે છે.
At a glance
અંદરની select queries મુખ્ય DML ક્રિયાઓમાં કેવી રીતે ભળે છે
| DML ક્રિયા | Subquery ની જગ્યા | ઉદાહરણનો હેતુ |
|---|---|---|
| INSERT | VALUES ને બદલે value આપતા clause ની અંદર | નિશાન કરેલા મોડા records ને એક audit table માં નકલ કરવા |
| UPDATE | SET value ની સોંપણી કે WHERE filter ની અંદર | નબળા દેખાવના આંકડાના આધારે પુસ્તકોની કિંમતો બદલવી |
| DELETE | WHERE conditional મેળવતા clause ની અંદર | વર્ષોથી કોઈ સક્રિય ઇતિહાસ ન ધરાવતા members કાઢવા |
Theory
Blacklist થયેલા Records સાફ કરવા
ચાલો એક ખરેખરો exam નો પ્રિય જોઈએ: 1000 રૂપિયાથી વધુ કિંમતનાં પુસ્તકો માટેના issue logs કાઢવા. પહેલાં, અંદરની query books table ફેંદે છે: SELECT book_id FROM books WHERE price > 1000. આ મળતા પુસ્તકના IDs ની એક યાદી પાછી આપે છે. પછી, બહારની query સંભાળી લે છે: DELETE FROM issues WHERE book_id IN (...);. Oracle અંદરની શોધ એક વાર ચલાવે છે, લક્ષ્ય IDs ભેગા કરે છે, અને મળતી rows તરત સાફ કરવા એ બહારના delete command ને સોંપે છે.
Quiz
જો એક UPDATE statement માટે WHERE clause ની અંદર વપરાયેલી એક અંદરની subquery અનેક rows પાછી આપે, પણ તમે સામાન્ય બરાબરનો ચિહ્ન (=) operator વાપર્યો હોય, તો શું થાય છે?
- Oracle માત્ર પહેલી હરોળ process કરે છે અને બાકીની અવગણે છે.
- Oracle એક Single-Row Subquery Returns More Than One Row નામની runtime error ફેંકે છે.
- Oracle આપોઆપ બરાબરના operator ને એક IN operator માં ફેરવી નાખે છે.
- Update statement સફળ થાય છે પણ બધાં લક્ષ્ય column ના fields NULL કરી નાખે છે.
Show the answer
Oracle એક Single-Row Subquery Returns More Than One Row નામની runtime error ફેંકે છે.
એક-હરોળનો બરાબરનો operator (=) subquery પાસેથી બિલકુલ એક જ value ની અપેક્ષા રાખે છે. જો subquery ને અનેક rows મળે, Oracle એક error સાથે execution અટકાવે છે. અનેક values ની યાદી સલામત રીતે સંભાળવા, તમારે IN જેવા multi-row operators વાપરવા પડશે.
Watch out
ખાલી Subquery નો Null ફાંદો
એક અંદરની subquery સાથે NOT IN વાપરતી વખતે સાવધ રહો! જો તમારી subquery એક પણ એવી હરોળ પાછી આપે જેમાં NULL value હોય, તો આખી બહારની condition અજ્ઞાત આંકાય છે. ઉદાહરણ તરીકે, member_id NOT IN (SELECT member_id FROM issues) વાળા members કાઢવાનો પ્રયાસ કરવાથી, જો કોઈ કોરા member ID વાળી issue ની હરોળ હોય તો એ સંપૂર્ણપણે એક પણ હરોળ કાઢવામાં નિષ્ફળ જશે. સલામત રહેવા હંમેશા તમારી nested queries ની અંદર એક WHERE column IS NOT NULL filter સામેલ કરો.
Think first
માનસિક Query રચનાની ચકાસણી
કલ્પો કે તમારે 500 રૂપિયાથી વધુ કિંમતનાં બધાં પુસ્તકો premium_books નામના એક અલગ ખાસ table માં નાખવાં છે. મનમાં માળખું ગોઠવો. શું આ insert ની કામગીરી દરમિયાન તમારે VALUES keyword સામેલ કરવો પડશે? Tap કરતાં પહેલાં ધ્યાનથી વિચારો.
Show the answer
ના, જ્યારે તમે સીધો એક subquery માંથી data નાખો ત્યારે તમે VALUES keyword વાપરતા નથી! સાચું Oracle SQL નું સ્વરૂપ છે: 'INSERT INTO premium_books SELECT * FROM books WHERE price > 500;'. અહીં VALUES keyword સામેલ કરવાથી સીધી એક syntax error ઊભી થશે.
Theory
વાસ્તવિક દુનિયાનું Data Warehousing
મોટા enterprise database ના configurations માં, કે Semester 4 ના projects માં database ના સ્થળાંતર દરમિયાન, DML કામગીરીની અંદરની subqueries અત્યંત મહત્ત્વની છે. એ engineers ને ગંદો data સાફ કરવા, ઐતિહાસિક records ને ઠંડા સંગ્રહનાં tables માં જમા કરવા, અને Java કે Python માં ધીમા, હાથે લખેલા backend loops લખ્યા વગર staging tables ને સરળતાથી સુમેળમાં લાવવા દે છે.
Summary
Key takeaways
- Subqueries એક data બદલતા statement ની અંદર એક SELECT કામગીરી જડે છે.
- INSERT commands hardcode કરેલી VALUES ની યાદીને બદલે સીધી એક subquery વાપરે છે.
- UPDATE અને DELETE statements પોતાના filter clauses ની અંદરની nested queries પર આધાર રાખે છે.
- Multi-row subquery નાં પરિણામોને IN કે ANY જેવા સ્પષ્ટ set operators જોઈએ છે.
- એક NOT IN subquery ની અંદર પાછી અપાયેલી એક જ NULL value આખા condition ના expression ને બગાડી નાખે છે.
- Memory hook: Nested queries લક્ષ્યો શોધે છે, બહારના commands કામ પૂરું કરે છે!