Theory
એક અજાણી હકીકતથી હજાર Records કેવી રીતે બદલો?
કલ્પો કે TicketDesk system માં એક કટોકટી થાય છે. Amit નામનો એક agent અચાનક રજા પર જતો રહ્યો છે, અને તમને એનાં બધાં ખુલ્લાં tickets તરત Critical priority પર ચઢાવવાનો હુકમ મળે છે. જો તમને ખબર હોય કે Amit નું agent ID 4 છે, એ એક સાદી query છે. પણ જો તમારી પાસે માત્ર એનું નામ હોય, અને એનું ID એક વિશાળ database માં કોઈ પણ મનફાવતો અંક હોઈ શકે તો? એક પરીક્ષા દરમિયાન કે એક production ના crash દરમિયાન તમે પહેલાં હાથે ID શોધીને એને બીજી query માં ટાઈપ કરી શકતા નથી. તમને એક query નો જવાબ સીધો બીજીમાં આપવાનો રસ્તો જોઈએ.
Theory
અંદરના પરબીડિયા વાળો Courier
એક executive assistant ને વિચારો જેને એક સીલ કરેલી સૂચના મળે છે: 'આ bonus નો check એ કર્મચારીને પહોંચાડો જેણે આ મહિને દેખાવનું ટોચનું ઇનામ જીત્યું.' Assistant ને હજી ખબર નથી કે ઇનામ કોણે જીત્યું. પહેલાં, એ વિજેતાનું નામ, Vijay, ધરાવતું એક અંદરનું પરબીડિયું ખોલે છે. એ નામ વાંચ્યા પછી, એ check પર Vijay નું નામ લખીને બહારની સૂચના પૂરી કરે છે. SQL માં, એક data બદલવાની query માં એક છુપાયેલી અંદરની query હોઈ શકે છે જે પહેલાં અજાણી data ની value શોધે છે.
Theory
DML કામગીરીમાં Subqueries ની વ્યાખ્યા
Oracle SQL માં, એક Subquery (કે nested query) એ બીજા SQL statement ની અંદર જડેલું એક SELECT statement છે. જ્યારે INSERT, UPDATE, કે DELETE જેવાં Data Manipulation Language (DML) statements ની અંદર વપરાય, અંદરની subquery એક data ની value કે values ની યાદી લાવવા બિલકુલ એક વાર ચાલે છે. પછી બહારનું DML statement એ પરિણામ તરત વાપરીને બિલકુલ નક્કી કરે છે કે database ના schema માંથી કઈ rows નાખવી, બદલવી, કે કાઢવી.
At a glance
Oracle SQL માં subqueries જુદા data બદલવાના commands ને કેવી રીતે શક્તિ આપે છે
| DML ક્રિયા | Subquery ની ભૂમિકા | વ્યવહારુ TicketDesk ઉદાહરણ |
|---|---|---|
| INSERT | ઉમેરવાની rows કે values આપે છે | જૂનાં ઉકેલાયેલાં tickets એક અલગ archive table માં નકલ કરવાં |
| UPDATE | નવી value શોધે છે કે લક્ષ્ય rows filter કરે છે | એક ચોક્કસ team દ્વારા સંભાળાયેલાં બધાં tickets નું status High કરવું |
| DELETE | હરોળ કાઢવાના માપદંડ ઓળખે છે | નિષ્ક્રિય કરેલા agent ના ખાતાં સાથે જોડાયેલાં બધાં tickets સાફ કરવાં |
Practical
Executing Subqueries within UPDATE and DELETE Statements
-- Step 1: Escalate tickets for an agent when you only know their name
UPDATE tickets
SET priority = 'Critical'
WHERE agent_id = (SELECT id FROM agents WHERE name = 'Amit');
-- Step 2: Delete tickets associated with agents whose names start with Test
DELETE FROM tickets
WHERE agent_id IN (SELECT id FROM agents WHERE name LIKE 'Test%');This example runs in Gri-Learn on the web, where you can edit it and see the output.
Quiz
જો એક UPDATE statement 'WHERE agent_id = (SELECT id FROM agents WHERE name = Liam)' ની અંદરની subquery 3 જુદાં IDs પાછાં આપે તો શું થશે?
- Oracle 3 માંથી કોઈ પણ ID સાથે મળતાં બધાં tickets સફળતાપૂર્વક update કરશે
- Oracle એક runtime error ફેંકશે કારણ કે એક single value operator (=) માત્ર 1 હરોળની અપેક્ષા રાખે છે
- Oracle update સંપૂર્ણપણે અવગણશે અને error વગર આગલા command પર જશે
- Oracle આપોઆપ equality operator ને એક IN operator માં બદલી નાખશે
Show the answer
Oracle એક runtime error ફેંકશે કારણ કે એક single value operator (=) માત્ર 1 હરોળની અપેક્ષા રાખે છે
Equality operator (=) એ એક હરોળનો operator છે. જો subquery અનેક rows પાછી આપે (જેમ કે 3 જુદાં IDs), Oracle નક્કી કરી શકતું નથી કે કયું વાપરવું અને એ એક error ફેંકશે: single-row subquery returns more than one row. અનેક rows સંભાળવા, તમારે (=) ને બદલે IN operator વાપરવો જ પડશે.
Think first
માનસિક પડકાર: INSERT સાથે Subquery
કલ્પો કે તમારી પાસે history_logs(ticket_id, title) નામનું એક ખાલી table છે. મનમાં એક INSERT statement રચો જે એક subquery વાપરીને 'Closed' status વાળાં બધાં tickets ના id અને title આ table માં નકલ કરે. ઉજાગર કરતાં પહેલાં પ્રયાસ કરો.
Show the answer
Query છે: INSERT INTO history_logs (ticket_id, title) SELECT id, title FROM tickets WHERE status = 'Closed'; નોંધો કે જ્યારે તમે સીધી એક subquery માંથી rows નાખો, ત્યારે તમે VALUES keyword વાપરતા નથી!
Watch out
VALUES Keyword ની ભૂલ
અનેક rows નકલ કરવા એક INSERT statement સાથે subquery વાપરતી વખતે, exam ના marks ગુમાવતી એક મોટી ભૂલ છે INSERT INTO table VALUES (SELECT ...); લખવું. Oracle SQL માં, VALUES ને એક multi-row subquery સાથે જોડવાથી એક syntax error થાય છે. VALUES keyword સંપૂર્ણપણે કાઢી નાખો અને INSERT statement ને સીધું data બનાવતા SELECT query ના માળખા પછી આવવા દો.
Theory
વાસ્તવિક દુનિયાની કામગીરી અને Sem 3 નાં જોડાણો
DML commands સાથે subqueries વાપરવી એ જથ્થાબંધ કામગીરી સંભાળતા database administrators માટે એક પાયાનું કૌશલ્ય છે. Python કે Java માં rows એક પછી એક update કરવા અલગ backend loops લખવાને બદલે, એક જ SQL query server ની બાજુએ તરત લાખો ફેરફારો સંભાળે છે. તમારા Sem 3 ના SQLite ના અભ્યાસક્રમમાં, તમે mobile app નો સ્થાનિક સંગ્રહ કાર્યક્ષમ રીતે સાફ કરવા બિલકુલ આ જ subquery ની તરકીબો વાપરશો.
Summary
Key takeaways
- એક subquery એ અંદરનું SELECT statement છે જે એક બહારના query ના statement ને data ની values આપે છે.
- Data ના ફેરફારો ગતિશીલ બનાવવા subqueries INSERT, UPDATE, અને DELETE ની કામગીરીની અંદર જડી શકાય છે.
- (=) જેવા એક હરોળના operators માત્ર ત્યારે વાપરો જ્યારે તમને ખાતરી હોય કે subquery બિલકુલ એક value પાછી આપે છે.
- જ્યારે અંદરની subquery અનેક મળતા records પાછા આપી શકે ત્યારે IN જેવા multi row operators વાપરો.
- એક subquery ના statement માંથી મેળવેલી rows નાખતી વખતે VALUES keyword ન વાપરો.
- Memory hook: અંદરની query હકીકતો ભેગી કરે છે, બહારની query ભૌતિક ફેરફારો કરે છે!