SQLite में, एक AUTOINCREMENT कॉलम वह है जो तालिका में डाली गई प्रत्येक पंक्ति के लिए स्वचालित रूप से बढ़े हुए मान का उपयोग करता है।
कुछ तरीके हैं जिनसे आप एक AUTOINCREMENT बना सकते हैं कॉलम:
- जब आप कॉलम को
INTEGER PRIMARY KEYके रूप में परिभाषित करते हैं, तो आप इसे परोक्ष रूप से बना सकते हैं . - आप इसे
AUTOINCREMENT. के साथ स्पष्ट रूप से बना सकते हैं खोजशब्द। इस पद्धति का एक नकारात्मक पहलू यह है कि यह अतिरिक्त CPU, मेमोरी, डिस्क स्थान और डिस्क I/O ओवरहेड का उपयोग करता है।
हर बार NULL . के साथ एक नई पंक्ति डालने पर दोनों विधियाँ कॉलम को एक बढ़ते हुए मान का उपयोग करने का कारण बनती हैं उस कॉलम में।
हालांकि, प्रत्येक विधि कैसे काम करती है, इसके बीच कुछ सूक्ष्म अंतर हैं।
ऑटोइनक्रिमेंट कीवर्ड के बिना
जब आप किसी कॉलम को INTEGER PRIMARY KEY . के रूप में घोषित करते हैं , यह स्वचालित रूप से वृद्धि होगी। इसलिए, आपको वास्तव में AUTOINCREMENT . का उपयोग करने की आवश्यकता नहीं है कीवर्ड के लिए एक कॉलम है जो प्रत्येक पंक्ति के लिए स्वचालित रूप से वृद्धिशील मान का उपयोग करता है।
जब आप ऐसा करते हैं, तो कोई भी NULL मान वर्तमान ROWID . में परिवर्तित हो जाते हैं . दूसरे शब्दों में, यदि आप NULL insert डालते हैं उस कॉलम में, इसे वर्तमान ROWID . में बदल दिया जाएगा ।
दरअसल, इसके काम करने का तरीका यह है कि कॉलम ROWID . के लिए एक उपनाम बन जाता है . आप ROWID . तक पहुंच सकते हैं चार नामों में से किसी का उपयोग करके मूल्य; कॉलम का नाम, ROWID , _ROWID_ , या OID ।
AUTOINCREMENT को छोड़ने का एक फायदा कीवर्ड यह है कि यह CPU, मेमोरी, डिस्क स्थान और डिस्क I/O ओवरहेड को कम करता है।
हालांकि, एक महत्वपूर्ण पहलू यह है कि आप इस बात की गारंटी नहीं दे सकते कि सभी पंक्तियों को आरोही क्रम में बढ़ाया जाएगा। यह AUTOINCREMENT को छोड़ कर ऑटो-इंक्रीमेंटिंग के काम करने के तरीके के कारण है कीवर्ड बनाम उस कीवर्ड का उपयोग करना।
जब आप AUTOINCREMENT . को छोड़ देते हैं कीवर्ड, एक बार ROWID सबसे बड़े संभावित पूर्णांक (9223372036854775807) के बराबर है, SQLite एक अप्रयुक्त धनात्मक ROWID को खोजने का प्रयास करेगा बेतरतीब ढंग से।
हालांकि, जब तक आप कभी भी अधिकतम ROWID . का उपयोग नहीं करते हैं मान और आप तालिका में सबसे बड़े ROWID . के साथ प्रविष्टि को कभी नहीं हटाते हैं , यह विधि नीरस रूप से बढ़ते हुए अद्वितीय ROWID . उत्पन्न करेगी एस.
स्वचालित कीवर्ड के साथ
आप स्पष्ट रूप से स्वतः-वृद्धिशील स्तंभ भी बना सकते हैं। ऐसा करने के लिए, AUTOINCREMENT का उपयोग करें खोजशब्द।
जब आप इस पद्धति का उपयोग करते हैं, तो ऑटो-इन्क्रीमेंटेड मान को निर्धारित करने के लिए थोड़ा अलग एल्गोरिदम का उपयोग किया जाता है।
जब आप AUTOINCREMENT का उपयोग करते हैं कीवर्ड, ROWID नई पंक्ति के लिए चुना गया सबसे बड़ा ROWID . से कम से कम एक बड़ा है जिसमें कभी . है पहले उसी तालिका में मौजूद था।
दूसरे शब्दों में, यह वापस नहीं जाएगा और पहले हटाए गए ROWID . का पुन:उपयोग नहीं करेगा मूल्य। एक बार सबसे बड़ा संभव ROWID डाला गया है, कोई नया डालने की अनुमति नहीं है। नई पंक्ति डालने का कोई भी प्रयास SQLITE_FULL . के साथ विफल हो जाएगा त्रुटि।
इसलिए इस पद्धति का उपयोग गारंटी देता है कि ROWID s एकरस रूप से बढ़ रहे हैं। दूसरे शब्दों में, ROWID . रखने के लिए आप इस विधि पर भरोसा कर सकते हैं s आरोही क्रम में।
इसका मतलब यह नहीं है कि मान हमेशा 1 से बढ़ेंगे। इसका सीधा सा मतलब है कि वे कभी कम नहीं होंगे।
उदाहरण
ऑटो-इन्क्रीमेंट कॉलम को स्पष्ट रूप से और स्पष्ट रूप से परिभाषित करने के बीच अंतर को प्रदर्शित करने के लिए यहां एक उदाहरण दिया गया है।
CREATE TABLE Cats(
CatId INTEGER PRIMARY KEY,
CatName
);
CREATE TABLE Dogs(
DogId INTEGER PRIMARY KEY AUTOINCREMENT,
DogName
);
INSERT INTO Cats VALUES
( NULL, 'Brush' ),
( NULL, 'Scarcat' ),
( NULL, 'Flutter' );
INSERT INTO Dogs VALUES
( NULL, 'Yelp' ),
( NULL, 'Woofer' ),
( NULL, 'Fluff' );
SELECT * FROM Cats;
SELECT * FROM Dogs;प्रारंभिक परिणाम:
CatId CatName ---------- ---------- 1 Brush 2 Scarcat 3 Flutter DogId DogName ---------- ---------- 1 Yelp 2 Woofer 3 Fluff
अब प्रत्येक तालिका की अंतिम पंक्ति को हटाते हैं, पंक्तियों को फिर से सम्मिलित करते हैं, फिर परिणाम का चयन करते हैं:
DELETE FROM Cats WHERE CatId = 3;
DELETE FROM Dogs WHERE DogId = 3;
INSERT INTO Cats VALUES ( NULL, 'New Flutter' );
INSERT INTO Dogs VALUES ( NULL, 'New Fluff' );
SELECT * FROM Cats;
SELECT * FROM Dogs;परिणाम:
CatId CatName ---------- ---------- 1 Brush 2 Scarcat 3 New Flutter DogId DogName ---------- ---------- 1 Yelp 2 Woofer 4 New Fluff
संक्षेप में, बिल्लियों तालिका बिना बनाई गई थी AUTOINCREMENT कीवर्ड, और कुत्तों तालिका के साथ . बनाई गई थी AUTOINCREMENT कीवर्ड।
बिल्लियों . से अंतिम पंक्ति को हटाने के बाद तालिका, अगला INSERT ऑपरेशन के परिणामस्वरूप समान ROWID उस पंक्ति के लिए पुन:उपयोग किया जा रहा है।
हालांकि, कुत्ते टेबल अलग थी। इसे AUTOINCREMENT . के साथ बनाया गया था कीवर्ड और इसलिए यह पिछले मान का पुन:उपयोग नहीं कर सकता है। यह संख्या में अंतर छोड़ते हुए बस अगले मान तक बढ़ जाता है।
अधिकतम ROWID
हम पिछले उदाहरण को एक कदम आगे ले जा सकते हैं और स्पष्ट रूप से अधिकतम ROWID का उपयोग करके एक नई पंक्ति सम्मिलित कर सकते हैं संभव है।
INSERT INTO Cats VALUES ( 9223372036854775807, 'Magnus' );
INSERT INTO Dogs VALUES ( 9223372036854775807, 'Maximus' );
SELECT * FROM Cats;
SELECT * FROM Dogs;परिणाम:
CatId CatName -------------------- -------------------- 1 Brush 2 Scarcat 3 New Flutter 9223372036854775807 Magnus DogId DogName -------------------- -------------------- 1 Yelp 2 Woofer 4 New Fluff 9223372036854775807 Maximus
ठीक है, इसलिए दोनों टेबल अपने सबसे बड़े ROWID . के रूप में सबसे बड़े संभावित पूर्णांक का उपयोग करते हैं मान।
आइए देखें कि क्या होता है जब मैं प्रत्येक तालिका में एक नई पंक्ति सम्मिलित करने का प्रयास करता हूं (स्वतः-वृद्धि वाले स्तंभों के लिए कोई मान स्पष्ट रूप से निर्दिष्ट किए बिना)।
बिल्लियों . में डालें तालिका:
INSERT INTO Cats VALUES ( NULL, 'Scratchy' );
SELECT * FROM Cats;परिणाम:
CatId CatName -------------------- -------------------- 1 Brush 2 Scarcat 3 New Flutter 267244677462397326 Scratchy 9223372036854775807 Magnus
तो बिल्लियों तालिका सफल रही। हालांकि, ध्यान दें कि नया ऑटो-इंक्रीमेंटिंग मान पिछले मान से कम है (इसका कोई अन्य विकल्प नहीं है)।
पंक्ति को सम्मिलित/अद्यतन करने की तिथि/समय को रिकॉर्ड करने के लिए कोई अन्य कॉलम न होने पर, कोई गलत तरीके से मान सकता है कि मैग्नस खरोंच . के बाद डाला गया था ।
आइए अब कुत्तों . में एक नई पंक्ति डालने का प्रयास करें तालिका:
INSERT INTO Dogs VALUES ( NULL, 'Lickable' );परिणाम:
Error: database or disk is full
तो हमें बिल्लियों . के लिए एक अलग परिणाम मिलता है टेबल।
मुझे यह त्रुटि इसलिए मिली क्योंकि सबसे बड़ा संभव ROWID तालिका में पहले से ही उपयोग किया जा रहा है, और क्योंकि यह तालिका AUTOINCREMENT के साथ बनाई गई थी कीवर्ड, यह वापस नहीं जाएगा और अप्रयुक्त ROWID . की खोज करेगा मूल्य।
SELECT * FROM Dogs;परिणाम:
DogId DogName -------------------- -------------------- 1 Yelp 2 Woofer 4 New Fluff 9223372036854775807 Maximus
इसके अलावा, मुझे यह त्रुटि मिलती रहेगी, भले ही मैं मैक्सिमस को हटा दूं तालिका से (अर्थात अधिकतम ROWID . वाला कुत्ता मूल्य)।
आइए इसे आजमाएं:
DELETE FROM Dogs WHERE DogId = 9223372036854775807;
INSERT INTO Dogs VALUES ( NULL, 'Lickable' );परिणाम:
Error: database or disk is full
इसलिए न केवल हमें एक त्रुटि मिलती है, बल्कि मैंने Maximus को भी हटा दिया है :
SELECT * FROM Dogs;परिणाम:
DogId DogName -------------------- -------------------- 1 Yelp 2 Woofer 4 New Fluff
यह ध्यान रखना महत्वपूर्ण है कि यह तब भी होगा जब मैं ROWID . बदल दूं कम मूल्य के लिए मूल्य। तथ्य यह है कि मैंने पहले ही 9223372036854775807 के एक ROWID का उपयोग किया है, इसका अर्थ है कि AUTOINCREMENT अब स्वचालित रूप से वृद्धि नहीं होगी।
ऐसा इसलिए है क्योंकि AUTOINCREMENT केवल उन मानों का उपयोग करता है जो किसी भी मान से कम से कम एक अधिक हैं जो उसी तालिका में पहले कभी मौजूद थे .
अब से, यदि मैं इस कॉलम में मान सम्मिलित करना जारी रखना चाहता हूँ, तो मुझे स्पष्ट रूप से मान सम्मिलित करना होगा। यह मानता है कि मेरे पास तालिका में पहले से ही 9223372036854775807 पंक्तियाँ नहीं हैं।
आइए मैक्सिमस को फिर से डालें कम ROWID . के साथ और पुनः प्रयास करें:
INSERT INTO Dogs VALUES ( 5, 'Maximus' );
SELECT * FROM Dogs;परिणाम:
DogId DogName -------------------- -------------------- 1 Yelp 2 Woofer 4 New Fluff 5 Maximus
आइए अब लिकेबल को सम्मिलित करने का प्रयास करें एक बार फिर AUTOINCREMENT . का उपयोग करते हुए :
INSERT INTO Dogs VALUES ( NULL, 'Lickable' );परिणाम:
Error: database or disk is full
इसलिए भले ही मैंने उस पंक्ति को हटा दिया है जिसमें अधिकतम ROWID है 9223372036854775807 का मान, यह अभी भी मुझे कॉलम को स्वतः बढ़ाने से रोकता है।
ठीक इसी तरह इसे डिजाइन किया गया था। अधिकतम ROWID पहले इस तालिका में रहा है और इसलिए AUTOINCREMENT उस तालिका में स्वचालित रूप से फिर से वृद्धि नहीं होगी।
उस तालिका में एक नई पंक्ति जोड़ने का एकमात्र तरीका ROWID . को मैन्युअल रूप से सम्मिलित करना है मूल्य।
INSERT INTO Dogs VALUES (6, 'Lickable');
SELECT * FROM Dogs;परिणाम:
DogId DogName -------------------- -------------------- 1 Yelp 2 Woofer 4 New Fluff 5 Maximus 6 Lickable
