Creating sequence

📖 Theory

પાછલો bill number શું હતો?

Meera જે દરેક bill છાપે છે એને એક unique number જોઈએ: 1, 2, 3... કાગળ પર એ પાછલી પર્ચી જુએ છે અને એક ઉમેરે છે. પણ હવે એનો પિતરાઈ ભાઈ પણ એક બીજા counter થી bills છાપે છે, અને બે વાર એમણે બંનેએ number 48 પકડ્યો, બે અલગ sales, એ જ bill number. audit વખતે અંધાધૂંધી.

'છેલ્લે વપરાયેલો number' પર હાથે નજર રાખવી એ જ ક્ષણે તૂટે છે જ્યારે એક કરતાં વધુ વ્યક્તિ એકસાથે insert કરે. Databases એને એક sequence થી ઉકેલે છે: એક object જેનું એકમાત્ર કામ છે આગળનો number આપવો, સુરક્ષિત રીતે, જે પણ પૂછે. ક્યારેય કોઈ duplicate નહીં.

📖 Theory

બેંક માં token dispenser

એક વ્યસ્ત બેંક ગ્રાહકોને 'કોણ છેલ્લે હતું' યાદ રાખવા નથી કહેતી. એક token મશીન 41, 42, 43... એક પ્રતિ દબાવ આપે છે, જે પણ આગળ દબાવે એને. બે લોકો લગભગ એક જ ક્ષણે દબાવે છે? એમને છતાં અલગ tokens મળે છે, મશીન ક્યારેય એ જ number બે વાર નથી આપતી. એક sequence database numbers માટે એ જ token dispenser છે: દબાવો (પૂછો), આગળની unique value મેળવો, ખાતરીબદ્ધ.

⌨️ Practical

A sequence for bill numbers

-- Create the dispenser (Oracle syntax)
CREATE SEQUENCE bill_seq
    START WITH 1
    INCREMENT BY 1;

-- Ask for the next number each time you insert a bill
INSERT INTO bills (bill_no, item)
VALUES (bill_seq.NEXTVAL, 'Sugar');   -- gets 1

INSERT INTO bills (bill_no, item)
VALUES (bill_seq.NEXTVAL, 'Tea');     -- gets 2

-- MySQL does the same with AUTO_INCREMENT on the column:
-- bill_no INT AUTO_INCREMENT PRIMARY KEY

📖 Theory

એ કેવી રીતે કામ કરે છે

CREATE SEQUENCE dispenser બનાવે છે; NEXTVAL આગળનો number માંગે છે (અને dispenser ને આગળ વધારે છે); CURRVAL મોજૂદા વાળા પર ડોકિયું કરે છે.

Options એને tune કરે છે: START WITH (પહેલો number), INCREMENT BY (પગલું, સામાન્ય રીતે 1), MAXVALUE, અને CYCLE (max પછી ફરી શરૂ).

મોટા ભાગના databases primary key IDs આપોઆપ ભરવા sequences વાપરે છે, તો તમે એમને ક્યારેય હાથે ઘડતા નથી. MySQL એ જ idea ને એક column keyword માં લપેટે છે: AUTO_INCREMENT. અલગ syntax, એકસમાન હેતુ: unique, આપોઆપ વધતા numbers.

🧩 Quiz

જ્યારે બે counters એક જ સમયે bills insert કરે છે, તો Meera ના હાથે 'છેલ્લો bill number' પર નજર રાખવા કરતાં એક sequence કેમ વધુ સારો છે?

1. એક sequence ખાતરી આપે છે કે દરેક request ને એક unique number મળે, એકસાથે inserts છતાં
2. એક sequence bills ઝડપથી છાપે છે
3. હાથે numbering ઓછું storage વાપરે છે
4. એક sequence બે bills ને સુરક્ષિત રીતે એક number વહેંચવા દે છે

💭 Think first

શું એક sequence numbers છોડે છે?

Meera જુએ છે કે એના bill numbers 47 થી 49 પર કૂદ્યા, number 48 ગાયબ છે. એને એક bug નો ડર છે. એક sequence માં એક gap શું ખરેખર એક સમસ્યા છે? વિચારો કે NEXTVAL શું ખાતરી આપે છે.

⚠️ Watch out

Marks ક્યાં કપાય છે

એ વિચારવું કે એક sequence કોઈ gaps નહીં ની ખાતરી આપે છે, એ uniqueness ની ખાતરી આપે છે, સળંગપણાની નહીં (rollbacks gaps છોડે છે). NEXTVAL (આગળ વધારે અને આગળનો પાછો આપે) ને CURRVAL (બસ ડોકિયું કરે) સાથે ભેળવવું. અને MySQL સમકક્ષ ન જાણવો, એક column પર AUTO_INCREMENT. exam-લાયક મુદ્દો છે કેમ sequences મોજૂદ છે: સ્વયંસંચાલિત, unique, concurrency-સુરક્ષિત numbering જે હાથની tracking ન આપી શકે.

📖 Theory

તમે sequences થી ઘેરાયેલા છો

Amazon પર દરેક order ID, IRCTC પર દરેક ticket number, Gri-Learn database માં દરેક row ID, એક sequence (કે AUTO_INCREMENT) એ એને બનાવ્યો. એ અદૃશ્ય plumbing છે જેને તમે હવે સમજો છો. આખો subject પૂરો કરવા એક lesson બચે છે: views, સાચવેલી queries જે virtual tables ની જેમ વર્તે છે. આગળ, અને છેલ્લે: views બનાવવા અને એ અસલી tables થી કેવી રીતે અલગ છે.

✅ Summary

Key takeaways

• એક sequence એક database object છે જે unique, વધતા numbers આપોઆપ બનાવે છે.
• primary keys અને bill/invoice numbers માટે વપરાય છે જેથી તમે ક્યારેય છેલ્લા વાળા પર હાથે નજર ન રાખો.
• CREATE SEQUENCE એને બનાવે છે; NEXTVAL આગળની value આપે છે; CURRVAL મોજૂદા પર ડોકિયું કરે છે.
• એ concurrency-સુરક્ષિત છે: ઘણા users એકસાથે insert કરે તોય કોઈ duplicate numbers નહીં.
• Gaps થઈ શકે (rollbacks થી) અને હાનિરહિત છે; એ uniqueness ની ખાતરી આપે છે, સળંગપણાની નહીં. MySQL AUTO_INCREMENT વાપરે છે.
• યાદ રાખવાની યુક્તિ: એક બેંક token dispenser, આગળના unique number માટે દબાવો.