अधिक

क्या QGIS में ID कॉलम के लिए auto_increment का कोई तरीका है?

क्या QGIS में ID कॉलम के लिए auto_increment का कोई तरीका है?


मैं एक काल्पनिक नक्शा बना रहा हूं और इसलिए मुझे बहुत सारे बिंदु, रेखाएं और निश्चित बहुभुज बनाने की जरूरत है। बाद में मैं अपने डेटा को जियोजोन के रूप में निर्यात करता हूं। लेकिन उससे पहले मुझे जाना होगा और हर तत्व को एक यूनिक आईडी देनी होगी।

मुझे एक विशेष सॉर्टिंग की आवश्यकता नहीं है, जैसे सबसे बड़े बहुभुज को सबसे छोटी आईडी मिलती है। मैं तो बस जरुरत सब बहुभुज साथ से एक ईद अंत में, के बग़ैर करते हुए आईटी मैन्युअल जैसे मुझे अभी करना है।

बहुत अच्छा होगा अगर कोई जानता है कि यह कैसे करना है।


फ़ील्ड कैलकुलेटर का उपयोग करने का तरीका है:

में कोई आईडी नहीं दी गई थी

  1. बिना कोई आईडी डाले हर फीचर को डिजिटाइज करें।
  2. निर्यात करने से पहले, फ़ील्ड कैलकुलेटर का उपयोग करके '$Id' अभिव्यक्ति के साथ अद्वितीय आईडी अपडेट करें।

कुछ आईडी पहले ही दी जा चुकी हैं

  1. यदि आपके पास पहले से ही आईडी है तो आप '-$Id' का उपयोग कर सकते हैं। सुनिश्चित करें कि आपने केवल नई सुविधाओं का चयन किया है जिसका अर्थ है कि वे आईडी पंक्ति में 'NULL' हैं। बस कॉलम को ऑर्डर करके ऐसा करें।
  2. अब चित्रों से चरण करें:


हलेलुजाह! या यूरेका। या जो कुछ भी। यह संभव है। शेपफाइल के साथ।

  1. यदि पहले से एक नहीं है, तो फीचर आईडी रखने के लिए एक फ़ील्ड जोड़ें, जैसे "FID" टाइप करें पूर्ण संख्या (पूर्णांक).
  2. खुला हुआ परत गुण (परत पर राइट-क्लिक करें और चुनें गुण… या परत पर डबल-क्लिक करें), पर क्लिक करें गुण प्रपत्र टैब, फिर नीचे आम अचिह्नित संपादन योग्य और अंदर चूक मैदान में डिफ़ॉल्ट मान प्रकारअधिकतम ("एफआईडी") + 1.

अनचेक करके संपादन योग्य, आप कोई अन्य मान दर्ज नहीं कर सकते हैं या जो है उसे हटा नहीं सकते हैं। ध्यान दें कि अगर आईडी के बिना मान हैं, तो इन मानों को अपडेट नहीं किया जाएगा। किसी बिंदु पर मैं जाँच के साथ प्रयोग करूँगा अद्यतन पर डिफ़ॉल्ट मान लागू करें और मेरे सूत्र को संशोधित करने के लिए शून्य या नल मान की जांच करने के लिए केवल उन रिकॉर्ड्स को अपडेट करने के लिए जब वे संपादित किए जाते हैं, 1 से अधिक मान वाले किसी भी रिकॉर्ड को नहीं। (इससे पहले इस पोस्ट में चर्चा की गई थी कि एफआईडी फ़ील्ड को अद्वितीय मानों के साथ कैसे अपडेट किया जाए, जो आपको करने की आवश्यकता होगी यदि आपने आकृति में पहले से ही सुविधाएँ होने के बाद फ़ील्ड को जोड़ा है।)

ध्यान दें कि यह वर्तमान मानचित्र फ़ाइल के साथ सहेजा गया है, न कि आकृति फ़ाइल के साथ, इसलिए उस आकृति को कई बार जोड़ने से आपको परत शैली के उस हिस्से को नई जोड़ी गई परत में कॉपी करने की आवश्यकता होगी। ऐसा करने के लिए, परत पर राइट-क्लिक करें, चुनें शैलियाँ > शैली की प्रतिलिपि बनाएँ > फ़ील्ड, और दूसरी परत पर राइट-क्लिक करें, चुनें शैलियाँ > शैली चिपकाएँ > सभी शैली श्रेणियाँ (या जारी रखें खेत) आप आकार के आधार पर शैली के उस हिस्से को किसी अन्य परत पर भी कॉपी कर सकते हैं, लेकिन आईडी फ़ील्ड का वही नाम होना चाहिए जो आप जिस परत से कॉपी कर रहे हैं।


मैं विनयन की पोस्ट में जोड़ना चाहता हूं और संक्षेप में उल्लेख करना चाहता हूं रौनम फ़ंक्शन, क्योंकि यह बहुत समान है और कुछ मामलों में थोड़ा अधिक सुविधाजनक हो सकता है।

ईद लौटाता है फ़ीचर आईडी, जिसका अर्थ है कि यह हमेशा शुरू होता है शून्य.
रौनम लौटाता है पंक्ति की संख्या, जिसका अर्थ है कि यह शुरू होता है एक.

तो, मूल रूप से, यदि आप चाहते हैं कि ऑटो-इन्क्रीमेंट 0 से शुरू हो जाए $आईडी, और यदि आप इसे 1 से शुरू करना चाहते हैं तो इसके लिए जाएं $राउनम.


क्यूजीआईएस 3 के लिए अद्यतन

मुझे पता है कि मुझे इसमें काफी देर हो चुकी है लेकिन कोई भी अपडेट देना हमेशा अच्छा होता है:

क्यूजीआईएस 3 में अब एक देशी उपकरण है जिसका उपयोग इस सटीक काम को करने के लिए किया जा सकता है और इसे "ऑटोइनक्रिमेंटल फील्ड जोड़ें" कहा जाता है।

क्षेत्र कैलकुलेटर में अभिव्यक्ति का उपयोग करने या कोई कोडिंग करने की आवश्यकता नहीं है, लेकिन फिर भी ये सभी अभी भी बहुत उपयोगी और जानने के लिए अच्छे हैं।


यह विषय यहां आया है: क्यूजीआईएस में ऑटो इंक्रीमेंट प्राइमरी की के साथ शेपफाइल बनाएं

मेरे सुझाव होंगे:

1) SQLITE / SpatialLite डेटाबेस INTEGER PRIMARY KEY पर सेट किए गए फ़ील्ड पर ऑटो-इंक्रीमेंटिंग का समर्थन करते हैं:

एक INSERT पर, यदि ROWID या INTEGER PRIMARY KEY कॉलम को स्पष्ट रूप से कोई मान नहीं दिया गया है, तो यह स्वचालित रूप से एक अप्रयुक्त पूर्णांक से भर जाएगा, जो आमतौर पर वर्तमान में उपयोग में आने वाले सबसे बड़े ROWID से अधिक होता है। यह सच है, भले ही AUTOINCREMENT कीवर्ड का उपयोग किया गया हो या नहीं।

हर बार जब आप पॉलीगॉन को संपादित/बनाते हैं, तो आप उनकी विशेषताओं को भर सकते हैं, और SQLITE इसे उस क्षेत्र में एक वृद्धिशील अद्वितीय मान देगा, जिसे आपने INTEGER PRIMARY KEY प्रकार पर सेट किया है।

जब आप GEOJSON को निर्यात करने के लिए तैयार होते हैं, तो आप अपनी UNIQUE ID के साथ पूरी तरह तैयार हो जाते हैं।

2) यदि शेपफाइल्स का उपयोग कर रहे हैं, तो INTEGER प्रकार का एक OBJECTID फ़ील्ड बनाएं और फ़ील्ड कैलकुलेटर अभिव्यक्ति का उपयोग करके उस फ़ील्ड को हर बार जब आप पॉलीगॉन को संपादित / बनाते हैं और उन्हें निर्यात करने की आवश्यकता होती है। आप एक बार बहुभुज की मूल आईडी खो देंगे, लेकिन .SHP का उपयोग करके इसे प्राप्त करने का यही एकमात्र तरीका है। (मुझे क्षेत्र कैलकुलेटर अभिव्यक्ति ढूंढनी होगी)।

PostGIS एक और डेटा स्रोत है जिसे आप एक्सप्लोर करना चाहते हैं, हालांकि SQLITE की तुलना में अधिक भारी लिफ्ट, आपको आगे बढ़ने पर ऐसी प्रणाली में मूल्य मिल सकता है ...


पुरानी पोस्ट लेकिन किसी और के लिए एक त्वरित समाधान की तलाश में मेरा $ID + 1 के साथ एक फ़ील्ड बनाना था और यह स्वचालित रूप से 1 से शुरू हो जाएगा!


यदि आपको मानवीय रूप से सुपाच्य किसी चीज की आवश्यकता नहीं है, तो अब एक आसान समाधान है: क्षेत्र के स्वामित्व में, "यूयूआईडी जेनरेटर" चुनें, और सब कुछ खाली छोड़ दें।

यह स्वचालित रूप से क्षेत्र में एक UUID बनाएगा। एक साधारण संख्या ($id या $rownum के अनुसार) के रूप में अनुकूल नहीं है, लेकिन शुरुआत से ही UUID को उत्पन्न करता है, इसलिए कोई क्रमिक कदम नहीं।


आप केवल पहले कॉलम (आईडी) को हटा सकते हैं और नया "वर्चुअल फ़ील्ड के रूप में" बना सकते हैं


बस फाइलों को कॉपी करें और एक सीएसवी कॉपी बनाएं और ओआईडी बनाकर फिर से प्रदर्शित करें और नए शेपफाइल या फीचर क्लास के रूप में निर्यात करें।


इन समाधानों ने अब मेरे लिए QGIS 2.01 ड्यूफोर में काम नहीं किया। टाइपिंग$आईडीअभिव्यक्ति इनपुट फ़ील्ड में 'आईडी' नामक एक नए या मौजूदा फ़ील्ड पर मुझे एक त्रुटि मिली "अभिव्यक्ति अमान्य है"

फंक्शन टाइप करने के लिए क्या काम किया था$राउनमऔर फिर "ओके" पर क्लिक करें


ऐसा करने का सबसे आसान तरीका शायद एक पायथन लिपि के साथ होगा या शायद यह फ़ील्ड कैलकुलेटर के साथ संभव है। क्षमा करें मेरे पास आपके लिए एक नहीं है, शायद कोई और करेगा। इस बीच, मैं इसके लिए एक पायथन लिपि की खोज करूंगा। मैंने इसके बारे में आर्कजीआईएस के लिए बहुत कुछ देखा है, लेकिन मुझे यकीन है कि क्यूजीआईएस के लिए कुछ है।


MYSQL में ऑटो इंक्रीमेंट की समस्या Issue

मैं JOB_NAME , SANDBOX , PARENT_JOB_NAME को प्राथमिक कुंजी और JOB_ID को ऑटो इंक्रीमेंट के रूप में रखना चाहता हूं क्योंकि मैं "ऑन डुप्लीकेट कुंजी अपडेट" का उपयोग कर रहा हूं और ऑटो-इंक्रीमेंट के कारण यह नई पंक्तियों को सम्मिलित कर रहा है और तालिका में डुप्लिकेट बना रहा है।

और प्राथमिक कुंजी से job_id हटाते समय। मुझे त्रुटि मिल रही है "गलत तालिका परिभाषा में केवल एक ऑटो कॉलम हो सकता है और इसे एक कुंजी के रूप में परिभाषित किया जाना चाहिए"


17 उत्तर 17

गारंटीकृत अद्वितीय पंक्ति पहचानकर्ता होना कभी भी बुरा विचार नहीं है। मुझे लगता है कि मुझे कभी नहीं कहना चाहिए & ndash लेकिन चलो भारी बहुमत के साथ चलते हैं यह एक अच्छा विचार है।

सैद्धांतिक संभावित डाउनसाइड्स में बनाए रखने के लिए एक अतिरिक्त सूचकांक और उपयोग किए जाने वाले अतिरिक्त भंडारण स्थान शामिल हैं। मेरे लिए किसी एक का उपयोग न करने का यह पर्याप्त कारण कभी नहीं रहा।

टीएलडीआर: यदि आपके पास पहले से प्रत्येक पंक्ति की पहचान करने का एक अनूठा तरीका नहीं है, तो ऑटो-इन्क्रीमेंट के बजाय यूयूआईडी का उपयोग करें।

मैं पहले के सभी उत्तरों से असहमत हूं। ऐसे कई कारण हैं जिनकी वजह से सभी तालिकाओं में स्वत: वेतन वृद्धि फ़ील्ड जोड़ना एक बुरा विचार है।

यदि आपके पास एक टेबल है जहां कोई स्पष्ट कुंजी नहीं है, तो एक ऑटो-इन्क्रीमेंट फ़ील्ड एक अच्छा विचार प्रतीत होता है। आखिरकार, आप ब्लॉग से * का चयन नहीं करना चाहते हैं जहाँ body = '[10000 character string]' है। आप इसके बजाय ब्लॉग से * चुनेंगे जहाँ >. मैं तर्क दूंगा कि इनमें से अधिकतर मामलों में, आप वास्तव में जो चाहते हैं वह एक अद्वितीय पहचानकर्ता है अनुक्रमिक अद्वितीय पहचानकर्ता नहीं। आप शायद इसके बजाय एक सार्वभौमिक रूप से अद्वितीय पहचानकर्ता का उपयोग करना चाहते हैं।

यादृच्छिक अद्वितीय पहचानकर्ता उत्पन्न करने के लिए अधिकांश डेटाबेस में फ़ंक्शन होते हैं ( uuid in mysql, postgres. newid in mssql)। ये आपको किसी भी समय, बिना किसी नेटवर्क कनेक्शन के, विभिन्न मशीनों पर कई डेटाबेस में डेटा उत्पन्न करने की अनुमति देते हैं, और फिर भी शून्य विरोध के साथ डेटा मर्ज करते हैं। यह आपको अधिक आसानी से कई सर्वर और यहां तक ​​कि डेटा केंद्रों को सेटअप करने की अनुमति देता है, उदाहरण के लिए, माइक्रोसर्विसेज के साथ।

यह हमलावरों को उन पृष्ठों के यूआरएल का अनुमान लगाने से भी बचाता है जिन तक उनकी पहुंच नहीं होनी चाहिए। यदि कोई https://example.com/user/1263 है तो संभवतः एक https://example.com/user/1262 भी है। यह उपयोगकर्ता प्रोफ़ाइल पृष्ठ में सुरक्षा शोषण के स्वचालन की अनुमति दे सकता है।

ऐसे कई मामले भी हैं जहां एक यूयूआईडी कॉलम बेकार है या हानिकारक भी है। मान लें कि आपके पास एक सोशल नेटवर्क है। एक उपयोगकर्ता तालिका और एक मित्र तालिका है। मित्र तालिका में दो उपयोगकर्ता आईडी कॉलम और एक ऑटो-इन्क्रीमेंट फ़ील्ड है। आप चाहते हैं कि 3 मित्र 5 के साथ हों, इसलिए आप डेटाबेस में 3,5 डालें। डेटाबेस एक ऑटो-इन्क्रीमेंट आईडी जोड़ता है और 1,3,5 स्टोर करता है। किसी तरह, उपयोगकर्ता 3 फिर से "दोस्त जोड़ें"-बटन पर क्लिक करता है। आप डेटाबेस में फिर से 3,5 डालें, डेटाबेस एक ऑटो-इंक्रीमेंट आईडी जोड़ता है और 2,3,5 सम्मिलित करता है। लेकिन अब 3 और 5 एक दूसरे के दो बार दोस्त हैं! यह जगह की बर्बादी है, और यदि आप इसके बारे में सोचते हैं, तो ऑटो-इन्क्रीमेंट कॉलम भी है। आपको केवल यह देखने की आवश्यकता है कि क्या a और b मित्र हैं, उन दो मानों वाली पंक्ति के लिए चयन करना है। वे एक साथ, एक अद्वितीय पंक्ति पहचानकर्ता हैं। (आप शायद यह सुनिश्चित करने के लिए कुछ तर्क लिखना चाहेंगे कि 3,5 और 5,3 काटे गए हैं।)

अभी भी ऐसे मामले हैं जहां अनुक्रमिक आईडी उपयोगी हो सकती है, जैसे यूआरएल-शॉर्टनर बनाते समय, लेकिन अधिकतर (और यहां तक ​​​​कि यूआरएल शॉर्टनर के साथ) एक यादृच्छिक रूप से जेनरेट की गई अनूठी आईडी वह है जिसे आप वास्तव में उपयोग करना चाहते हैं।

Autoincemental कुंजियों के ज्यादातर फायदे हैं।

लेकिन कुछ संभावित कमियां हो सकती हैं:

  • यदि आपके पास एक व्यावसायिक कुंजी है, तो आपको व्यावसायिक नियमों को लागू करने के लिए उस कॉलम पर भी एक अद्वितीय अनुक्रमणिका जोड़नी होगी।
  • दो डेटाबेस के बीच डेटा ट्रांसफर करते समय, खासकर जब डेटा एक से अधिक टेबल (यानी मास्टर/विवरण) में होता है, तो यह सीधा नहीं होता है क्योंकि डेटाबेस के बीच सीक्वेंस सिंक नहीं होते हैं, और आपको पहले इसका उपयोग करके एक तुल्यता तालिका बनानी होगी। व्यापार कुंजी एक मैच के रूप में यह जानने के लिए कि मूल डेटाबेस से कौन सी आईडी लक्ष्य डेटाबेस में किस आईडी से मेल खाती है। हालांकि, अलग-अलग तालिकाओं से/डेटा स्थानांतरित करते समय यह कोई समस्या नहीं होनी चाहिए।
  • कई उद्यमों में एड-हॉक, ग्राफिकल, पॉइंट-एंड-क्लिक, ड्रैग-एंड-ड्रॉप रिपोर्टिंग टूल होते हैं। चूंकि ऑटोइनक्रिमेंटल आईडी अर्थहीन हैं, इस प्रकार के उपयोगकर्ताओं के लिए "ऐप" के बाहर डेटा को समझना मुश्किल होगा।
  • यदि आप गलती से व्यवसाय कुंजी को संशोधित करते हैं, तो संभावना है कि आप उस पंक्ति को कभी भी पुनर्प्राप्त नहीं कर पाएंगे क्योंकि अब आपके पास मनुष्यों के लिए इसे पहचानने के लिए कुछ नहीं है। इससे एक बार बिटकॉइन प्लेटफॉर्म में खराबी आ गई थी।
  • कुछ डिज़ाइनर दो तालिकाओं के बीच जुड़ने वाली तालिका में एक आईडी जोड़ते हैं, जब पीके को केवल दो विदेशी आईडी से बना होना चाहिए। स्पष्ट रूप से यदि जॉइन टेबल तीन या अधिक तालिकाओं के बीच है, तो एक ऑटोइन्क्रिमेंटल आईडी समझ में आता है, लेकिन फिर आपको व्यावसायिक नियमों को लागू करने के लिए FK के संयोजन पर लागू होने पर एक अद्वितीय कुंजी जोड़नी होगी।

यहाँ सरोगेट कुंजियों के नुकसान पर विकिपीडिया लेख अनुभाग है।

इसके विपरीत, नहीं, आपको हमेशा एक संख्यात्मक AutoInc PK रखने की आवश्यकता नहीं है।

यदि आप अपने डेटा का सावधानीपूर्वक विश्लेषण करते हैं तो आप अक्सर डेटा में प्राकृतिक कुंजियों की पहचान करते हैं। यह अक्सर ऐसा होता है जब डेटा का व्यवसाय के लिए आंतरिक अर्थ होता है। कभी-कभी पीके प्राचीन प्रणालियों की कलाकृतियाँ होती हैं जिनका उपयोग व्यावसायिक उपयोगकर्ता अपने सिस्टम की विशेषताओं का वर्णन करने के लिए दूसरी भाषा के रूप में करते हैं। मैंने उदाहरण के लिए एक बेड़े प्रबंधन प्रणाली में "वाहन" तालिका की प्राथमिक कुंजी के रूप में उपयोग किए जाने वाले वाहन VIN नंबर देखे हैं।

हालाँकि यह उत्पन्न हुआ है, यदि आपके पास पहले से ही एक विशिष्ट पहचानकर्ता है, तो इसका उपयोग करें। दूसरी, अर्थहीन प्राथमिक कुंजी न बनाएं, यह बेकार है और इससे त्रुटियां हो सकती हैं।

कभी-कभी आप ग्राहक को सार्थक मूल्य उत्पन्न करने के लिए AutoInc PK का उपयोग कर सकते हैं उदा। पॉलिसी नंबर। शुरुआती मूल्य को कुछ समझदार और अग्रणी शून्य आदि के बारे में व्यावसायिक नियमों को लागू करना। यह शायद "दोनों दुनिया का सर्वश्रेष्ठ" दृष्टिकोण है।

जब आपके पास अपेक्षाकृत कम संख्या में मान होते हैं, तो उन मानों का उपयोग करें जो सिस्टम उपयोगकर्ता के लिए मायने रखते हैं। 1,2,3 का उपयोग क्यों करें जब आप एल, सी, एच का उपयोग कर सकते हैं जहां एल, एच और सी बीमा "पॉलिसी प्रकार" संदर्भ में जीवन, कार और घर का प्रतिनिधित्व करते हैं, या वीआईएन उदाहरण पर लौटते हैं, "TO" का उपयोग करने के बारे में कैसे "टोयोटा के लिए? सभी Toyata कारों में एक VIN होता है जो "TO" से शुरू होता है यह उपयोगकर्ताओं के लिए याद रखने वाली एक कम बात है, जिससे उनके लिए प्रोग्रामिंग और उपयोगकर्ता त्रुटियों को पेश करने की संभावना कम हो जाती है और प्रबंधन रिपोर्ट में पूर्ण विवरण के लिए उपयोग करने योग्य सरोगेट भी हो सकता है जिससे रिपोर्ट सरल हो जाती है। लिखने के लिए और शायद उत्पन्न करने के लिए तेज़।

इसका एक और विकास शायद "एक पुल बहुत दूर" है और मैं आमतौर पर इसकी अनुशंसा नहीं करता लेकिन मैं इसे पूर्णता के लिए शामिल कर रहा हूं और आपको इसके लिए एक अच्छा उपयोग मिल सकता है। यही है, विवरण को प्राथमिक कुंजी के रूप में उपयोग करें। तेजी से बदलते डेटा के लिए यह एक घृणित है। के लिये बहुत स्थिर डेटा जो रिपोर्ट किया गया है सभी समय, शायद नहीं। बस इसका जिक्र कर रहा हूं इसलिए यह वहां एक संभावना के रूप में बैठा है।

मैं AutoInc PK का उपयोग करता हूँ, मैं बस अपना दिमाग लगाता हूँ और पहले बेहतर विकल्पों की तलाश करता हूँ। डेटाबेस डिज़ाइन की कला कुछ सार्थक बना रही है जिसे जल्दी से खोजा जा सकता है। ज्यादा जॉइन होने से इसमें बाधा आती है।

संपादित करें एक अन्य महत्वपूर्ण मामला जहां आपको ऑटोजेनरेटेड पीके की आवश्यकता नहीं है, वह टेबल का मामला है जो दो अन्य तालिकाओं के चौराहे का प्रतिनिधित्व करता है। कार सादृश्य के साथ रहने के लिए, एक कार में 0..n एक्सेसरीज़ हैं, प्रत्येक एक्सेसरी कई कारों पर पाई जा सकती है। तो इसका प्रतिनिधित्व करने के लिए आप एक Car_Accessory तालिका बनाते हैं जिसमें कार और एक्सेसरी से पीके और लिंक तिथियों आदि के बारे में अन्य प्रासंगिक जानकारी होती है।

आपको (आमतौर पर) इस टेबल पर एक AutoInc PK की आवश्यकता नहीं होती है - इसे केवल कार के माध्यम से एक्सेस किया जाएगा "मुझे बताएं कि इस कार में कौन से एक्सेसरीज़ हैं" या एक्सेसरी से "उन्हें बताएं कि किन कारों में यह एक्सेसरी है"

कई तालिकाओं में पहले से ही एक प्राकृतिक अद्वितीय आईडी होती है। इन तालिकाओं में एक और विशिष्ट आईडी कॉलम (ऑटो-इन्क्रीमेंट या अन्यथा) न जोड़ें। इसके बजाय प्राकृतिक अद्वितीय आईडी का प्रयोग करें। यदि आप एक और विशिष्ट आईडी जोड़ते हैं, तो आपके डेटा में अनिवार्य रूप से एक अतिरेक (दोहराव या निर्भरता) है। यह सामान्यीकरण के सिद्धांतों के खिलाफ जाता है। सटीकता के लिए एक अद्वितीय आईडी दूसरे पर निर्भर है। इसका मतलब है कि उन्हें पूरी तरह से सिंक में रखा जाना है हर समय में हर प्रणाली जो इन पंक्तियों का प्रबंधन करता है। यह आपकी डेटा अखंडता में एक और नाजुकता है जिसे आप वास्तव में लंबे समय तक प्रबंधित और मान्य नहीं करना चाहते हैं।

इन दिनों अधिकांश तालिकाओं को वास्तव में बहुत मामूली प्रदर्शन को बढ़ावा देने की आवश्यकता नहीं है जो एक अतिरिक्त अद्वितीय आईडी कॉलम देगा (और कभी-कभी यह प्रदर्शन से भी अलग हो जाता है)। आईटी में एक सामान्य नियम के रूप में, जैसे अतिरेक से बचें प्लेग! हर जगह इसका विरोध करें जो आपको सुझाया गया है। यह अभिशाप है। और बोली का ध्यान रखें। सब कुछ यथासंभव सरल होना चाहिए, लेकिन सरल नहीं। दो अद्वितीय आईडी न रखें जहां एक पर्याप्त होगा, भले ही प्राकृतिक कम साफ-सुथरा लगे।

बड़े सिस्टम पर, आईडी कंसिस्टेंसी बूस्टर है, इसका इस्तेमाल जरूर करें लगभग कहीं भी। इस संदर्भ में, व्यक्तिगत प्राथमिक कुंजियों की अनुशंसा नहीं की जाती है, वे नीचे की रेखा पर महंगे हैं (क्यों पढ़ें)।

प्रत्येक नियम में एक अपवाद होता है, इसलिए हो सकता है कि आपको निर्यात/आयात के लिए उपयोग की जाने वाली स्टेजिंग टेबल और समान एक-तरफ़ा तालिकाओं या अस्थायी तालिकाओं पर पूर्णांक ऑटोइनक्रिकमेंट आईडी की आवश्यकता न हो। आप वितरित सिस्टम पर आईडी के बजाय GUID को भी पसंद करेंगे।

यहां कई उत्तर बताते हैं कि मौजूदा अद्वितीय कुंजी ली जानी चाहिए। ठीक है, भले ही इसमें 150 वर्ण हों? मुझे ऐसा नहीं लगता।

अब मेरा मुख्य बिंदु:

ऐसा लगता है कि ऑटोइनक्रिकमेंट इंटीजर आईडी के विरोधी 20 टेबल तक के छोटे डेटाबेस के बारे में बात कर रहे हैं। वहां वे प्रत्येक टेबल के लिए अलग-अलग दृष्टिकोण का खर्च उठा सकते हैं।

लेकिन एक बार आपके पास 400+ टेबल के साथ एक ईआरपी हो, जिसमें पूर्णांक ऑटोइनक्रिकमेंट आईडी कहीं भी हो (ऊपर वर्णित मामलों को छोड़कर) बस बहुत अच्छा समझ में आता है। आप अन्य अद्वितीय क्षेत्रों पर भरोसा नहीं करते हैं, भले ही वे मौजूद हों और विशिष्टता के लिए सुरक्षित हों।

  • आप सार्वभौमिक समय-बचत, प्रयास-बचत, याद रखने में आसान सम्मेलन से लाभान्वित होते हैं।
  • ज्यादातर मामलों में आप तालिकाओं में शामिल होते हैं, बिना यह जांचे कि चाबियां क्या हैं।
  • आपके पास अपने पूर्णांक ऑटोइनक्रिकमेंट कॉलम के साथ काम करने वाले सार्वभौमिक कोड रूटीन हो सकते हैं।
  • आप अपने सिस्टम को नई तालिकाओं या उपयोगकर्ता प्लगइन्स के साथ विस्तारित कर सकते हैं जिनकी पहले से कल्पना नहीं की गई थी, केवल मौजूदा तालिकाओं के आईडी का संदर्भ देकर। वे पहले से ही हैं, उन्हें अतिरिक्त रूप से जोड़ने की कोई कीमत नहीं है।

बड़ी प्रणालियों पर, उन व्यक्तिगत प्राथमिक कुंजियों के मामूली लाभों को अनदेखा करना और ज्यादातर मामलों में लगातार पूर्णांक ऑटोइनक्रिकमेंट आईडी का उपयोग करना उचित हो सकता है। प्राथमिक कुंजी के रूप में मौजूदा अद्वितीय फ़ील्ड का उपयोग करना शायद प्रति रिकॉर्ड कुछ बाइट्स सहेज रहा है लेकिन अतिरिक्त संग्रहण या अनुक्रमण समय मुद्रा सत्यापन प्रकार आज के डेटाबेस इंजन में। वास्तव में आप डेवलपर्स/रखरखावों के बर्बाद समय पर बहुत अधिक पैसा और संसाधन खो रहे हैं। आज के सॉफ़्टवेयर को प्रोग्रामर्स के समय और प्रयास के लिए अनुकूलित किया जाना चाहिए - संगत आईडी के साथ कौन सा दृष्टिकोण बेहतर तरीके से पूरा करता है।

यह अनावश्यक डिजाइनों के लिए अच्छा अभ्यास नहीं है। अर्थात। - जब किसी की आवश्यकता न हो तो हमेशा एक ऑटो इंक्रीमेंट int प्राथमिक कुंजी रखना अच्छा अभ्यास नहीं है।

आइए एक उदाहरण देखें जहां किसी की आवश्यकता नहीं है।

आपके पास लेखों के लिए एक टेबल है-इसमें एक इंट प्राथमिक कुंजी है ईद , और एक वर्चर कॉलम जिसका नाम है शीर्षक .

आपके पास लेख श्रेणियों से भरी एक तालिका भी है- id int प्राथमिक कुंजी, varchar name ।

आलेख तालिका में एक पंक्ति में एक है ईद 5 का, और एक शीर्षक "मक्खन के साथ हंस कैसे पकाना है"। आप उस लेख को अपनी श्रेणियाँ तालिका में निम्न पंक्तियों के साथ लिंक करना चाहते हैं: "Fowl" (ईद: 20), "हंस" (ईद: 12), "कुकिंग" (ईद: 2), "मक्खन" (आईडी: 9)।

अब, आपके पास 2 टेबल हैं: लेख और श्रेणियां। आप दोनों के बीच संबंध कैसे बनाते हैं?

आपके पास 3 कॉलम वाली एक टेबल हो सकती है: आईडी (प्राथमिक कुंजी), article_id (विदेशी कुंजी), श्रेणी_आईडी (विदेशी कुंजी)। लेकिन अब आपके पास कुछ ऐसा है:

एक बेहतर उपाय यह है कि प्राथमिक कुंजी 2 कॉलम से बनी हो।

यह करके पूरा किया जा सकता है:

ऑटो इंक्रीमेंट पूर्णांक का उपयोग न करने का एक अन्य कारण यह है कि यदि आप अपनी प्राथमिक कुंजी के लिए यूयूआईडी का उपयोग कर रहे हैं।

यूयूआईडी उनकी परिभाषा के अनुसार अद्वितीय हैं, जो वही काम पूरा करता है जो अद्वितीय पूर्णांक का उपयोग करता है। पूर्णांकों पर उनके अपने अतिरिक्त लाभ (और विपक्ष) भी हैं। उदाहरण के लिए, यूयूआईडी के साथ, आप जानते हैं कि आप जिस अद्वितीय स्ट्रिंग का जिक्र कर रहे हैं वह किसी विशेष डेटा रिकॉर्ड को इंगित करता है, यह उन मामलों में उपयोगी है जहां आपके पास 1 केंद्रीय डेटाबेस नहीं है, या जहां एप्लिकेशन में डेटा रिकॉर्ड ऑफ़लाइन बनाने की क्षमता है ( फिर उन्हें बाद की तारीख में डेटाबेस में अपलोड करें)।

अंत में, आपको प्राथमिक कुंजी के बारे में एक चीज़ के रूप में सोचने की ज़रूरत नहीं है। आपको उन्हें उनके द्वारा किए जाने वाले कार्य के रूप में सोचने की आवश्यकता है। आपको प्राथमिक कुंजी की आवश्यकता क्यों है? किसी फ़ील्ड का उपयोग करके तालिका से डेटा के विशिष्ट सेट की विशिष्ट रूप से पहचान करने में सक्षम होने के लिए जिसे भविष्य में नहीं बदला जाएगा। क्या आपको ऐसा करने के लिए आईडी नामक एक विशेष कॉलम की आवश्यकता है, या आप अन्य (अपरिवर्तनीय) डेटा के आधार पर इस विशिष्ट पहचान को आधार बना सकते हैं?

या क्या ऐसे परिदृश्य हैं जहां आप ऐसा कोई क्षेत्र नहीं जोड़ना चाहते हैं?

सबसे पहले, ऐसे डेटाबेस हैं जिनमें कोई ऑटोइनक्रिकमेंट नहीं है (उदाहरण के लिए, ओरेकल, जो निश्चित रूप से आसपास के सबसे छोटे दावेदारों में से एक नहीं है)। यह पहला संकेत होना चाहिए कि हर कोई उन्हें पसंद या जरूरत नहीं है।

अधिक महत्वपूर्ण, इस बारे में सोचें कि वास्तव में आईडी क्या है है - यह आपके डेटा की प्राथमिक कुंजी है। यदि आपके पास एक अलग प्राथमिक कुंजी वाली तालिका है, तो आपको एक आईडी की आवश्यकता नहीं है, और एक नहीं होनी चाहिए। उदाहरण के लिए, एक तालिका (EMPLOYEE_ID, TEAM_ID) (जहां प्रत्येक कर्मचारी एक साथ कई टीमों में हो सकता है) में स्पष्ट रूप से परिभाषित प्राथमिक कुंजी होती है जिसमें वे दो आईडी होते हैं। एक ऑटोइनक्रिकमेंट आईडी कॉलम जोड़ना, जो इस तालिका के लिए प्राथमिक कुंजी भी है, इसका कोई मतलब नहीं होगा। अब आप 2 प्राथमिक कुंजियों को इधर-उधर कर रहे हैं, और "प्राथमिक कुंजी" में पहला शब्द आपको एक संकेत देना चाहिए कि आपके पास वास्तव में केवल एक होना चाहिए।

"लंबे समय तक रहने वाले" डेटा के लिए नई तालिकाओं को परिभाषित करते समय मैं आमतौर पर "पहचान" कॉलम (स्वत: वृद्धिशील पूर्णांक) का उपयोग करता हूं (रिकॉर्ड जो मैं एक बार डालने की उम्मीद करता हूं और अनिश्चित काल तक रखता हूं, भले ही वे थोड़ा सा फ़ील्ड सेट करके "तार्किक रूप से हटाए गए" समाप्त हो जाएं )

ऐसी कुछ स्थितियां हैं जिनके बारे में मैं सोच सकता हूं जब आप उनका उपयोग नहीं करना चाहते हैं, जिनमें से अधिकतर परिदृश्यों में उबालते हैं जहां डीबी के एक उदाहरण पर एक तालिका नए आईडी मानों के लिए आधिकारिक स्रोत नहीं हो सकती है:

  • जब संभावित हमलावर के लिए वृद्धिशील आईडी बहुत अधिक जानकारी होगी। "सार्वजनिक-सामना" डेटा सेवाओं के लिए एक पहचान कॉलम का उपयोग आपको "जर्मन टैंक समस्या" के प्रति संवेदनशील बनाता है यदि रिकॉर्ड आईडी 10234 मौजूद है, तो इसका कारण यह है कि रिकॉर्ड 10233, 10232, आदि मौजूद हैं, कम से कम रिकॉर्ड 10001 पर वापस जाएं, और तो यह पता लगाने के लिए कि आपका पहचान कॉलम कहां से शुरू हुआ, रिकॉर्ड 1001, 101 और 1 की जांच करना आसान है। मुख्य रूप से यादृच्छिक डेटा से बना V4 GUID डिज़ाइन द्वारा इस वृद्धिशील व्यवहार को तोड़ते हैं, ताकि सिर्फ एक GUID मौजूद होने के कारण, GUID के बाइट को बढ़ाने या घटाने के द्वारा बनाया गया GUID आवश्यक रूप से मौजूद नहीं है, जिससे हमलावर के लिए इच्छित सेवा का उपयोग करना कठिन हो जाता है। डंप टूल के रूप में एकल-रिकॉर्ड पुनर्प्राप्ति के लिए। ऐसे अन्य सुरक्षा उपाय हैं जो पहुंच को बेहतर ढंग से प्रतिबंधित कर सकते हैं, लेकिन इससे मदद मिलती है।
  • एम: एम क्रॉस-रेफरेंस टेबल में। यह एक तरह का गिम्मे है लेकिन मैंने इसे पहले देखा है। यदि आपके डेटाबेस में दो तालिकाओं के बीच कई-से-अनेक संबंध हैं, तो समाधान एक क्रॉस-रेफरेंस तालिका है जिसमें प्रत्येक तालिका के पीके को संदर्भित करने वाले विदेशी कुंजी कॉलम होते हैं। अंतर्निहित अनुक्रमणिका व्यवहार प्राप्त करने और संदर्भों की विशिष्टता सुनिश्चित करने के लिए, इस तालिका का PK वस्तुतः हमेशा दो विदेशी कुंजियों की एक मिश्रित कुंजी होना चाहिए।
  • जब आप इस टेबल पर थोक में डालने और हटाने की योजना बनाते हैं। संभवतः पहचान स्तंभों के लिए सबसे बड़ा नुकसान यह है कि किसी अन्य तालिका या क्वेरी से पंक्तियों को सम्मिलित करते समय आपको अतिरिक्त घेरा से गुजरना पड़ता है, जहाँ आप मूल तालिका के प्रमुख मूल्यों को बनाए रखना चाहते हैं। आपको "पहचान डालने" को चालू करना होगा (हालाँकि यह आपके डीबीएमएस में किया गया है), फिर मैन्युअल रूप से सुनिश्चित करें कि आपके द्वारा डाली जा रही कुंजियाँ अद्वितीय हैं, और फिर जब आप आयात के साथ कर रहे हैं तो आपको पहचान काउंटर सेट करना होगा तालिका का मेटाडेटा मौजूद अधिकतम मान तक। यदि यह ऑपरेशन इस टेबल पर बहुत अधिक होता है, तो एक अलग पीके योजना पर विचार करें।
  • वितरित तालिकाओं के लिए। आइडेंटिटी कॉलम सिंगल-इंस्टेंस डेटाबेस, फेलओवर पेयर और अन्य परिदृश्यों के लिए बहुत अच्छा काम करते हैं, जहां एक डेटाबेस इंस्टेंस किसी भी समय संपूर्ण डेटा स्कीमा पर एकमात्र अधिकार होता है। हालाँकि, केवल इतना बड़ा है कि आप जा सकते हैं और अभी भी एक कंप्यूटर पर्याप्त तेज़ होना चाहिए। प्रतिकृति या लेन-देन लॉग शिपिंग से आपको केवल-पढ़ने के लिए अतिरिक्त प्रतियां मिल सकती हैं, लेकिन उस समाधान के पैमाने की भी एक सीमा होती है। जल्दी या बाद में आपको दो या दो से अधिक सर्वर इंस्टेंस की आवश्यकता होगी जो डेटा के सम्मिलन को संभालेंगे और फिर एक दूसरे के साथ सिंक्रनाइज़ करेंगे। जब वह स्थिति आती है, तो आप एक वृद्धिशील के बजाय एक GUID फ़ील्ड चाहते हैं, क्योंकि अधिकांश डीबीएमएस GUID के एक हिस्से का उपयोग करने के लिए पूर्व-कॉन्फ़िगर किए जाते हैं जो वे एक उदाहरण-विशिष्ट पहचानकर्ता के रूप में उत्पन्न करते हैं, फिर शेष पहचानकर्ता को यादृच्छिक रूप से उत्पन्न करते हैं या क्रमिक रूप से। किसी भी मामले में, दो GUID जनरेटर के बीच टकराव की संभावना शून्य है, जबकि एक पहचान पूर्णांक कॉलम इस स्थिति में प्रबंधन करने के लिए एक बुरा सपना है (आप बीज को ऑफसेट करके और वेतन वृद्धि को 2 पर सेट करके भी/विषम जा सकते हैं, लेकिन यदि एक सर्वर आप जिस आईडी को बर्बाद कर रहे हैं, उससे अधिक गतिविधि देखता है)।
  • जब आपको डीबी में एकाधिक तालिकाओं में विशिष्टता को लागू करना होता है। उदाहरण के लिए, लेखा प्रणालियों में सामान्य खाता-बही का प्रबंधन करना (प्रत्येक खाते के प्रत्येक क्रेडिट या डेबिट के लिए एक पंक्ति के साथ, जो कभी हुआ है, इसलिए यह बहुत जल्दी हो जाता है) तालिकाओं के अनुक्रम के रूप में प्रत्येक एक कैलेंडर माह का प्रतिनिधित्व करता है/ साल। फिर रिपोर्टिंग के लिए उन्हें एक साथ जोड़ने के लिए दृश्य बनाए जा सकते हैं। तार्किक रूप से, यह सब एक बहुत बड़ी तालिका है, लेकिन इसे काट देने से DB का रखरखाव कार्य आसान हो जाता है। हालांकि, यह डुप्लिकेट कुंजियों के साथ समाप्त किए बिना एकाधिक तालिकाओं में सम्मिलन को प्रबंधित करने की समस्या प्रस्तुत करता है (आपको अगले महीने में लेनदेन लॉगिंग शुरू करने की इजाजत देता है)। फिर से, पहचान पूर्णांक स्तंभों के बजाय GUIDs गो-टू समाधान हैं, क्योंकि DBMS को इन्हें वास्तव में अद्वितीय तरीके से उत्पन्न करने के लिए डिज़ाइन किया गया है, ताकि एक एकल GUID मान पूरे DBMS में एक बार और केवल एक बार देखा जा सके।

ऐसे वर्कअराउंड हैं जो इन स्थितियों में पहचान कॉलम के उपयोग की अनुमति देते हैं, जैसा कि मैंने उम्मीद से उल्लेख किया है, लेकिन इनमें से अधिकांश में, पहचान पूर्णांक कॉलम से GUID में अपग्रेड करना सरल है और समस्या को पूरी तरह से हल करता है।

एक ऑटो-इन्क्रिमेंटेड (पहचान) प्राथमिक कुंजी एक अच्छा विचार है, सिवाय इसके कि यह डेटाबेस के संदर्भ और उस डेटाबेस के तत्काल क्लाइंट के बाहर अर्थहीन है। उदाहरण के लिए, यदि आप कुछ डेटा को किसी अन्य डेटाबेस में स्थानांतरित और संग्रहीत करते हैं, तो दोनों डेटाबेस तालिकाओं में अलग-अलग डेटा लिखने के लिए आगे बढ़ें, आईडी का विचलन होगा - यानी, एक डेटाबेस में 42 की आईडी वाला डेटा आवश्यक रूप से डेटा से मेल नहीं खाएगा दूसरे में 42 की आईडी के साथ।

इसे देखते हुए, यदि अभी भी डेटाबेस के बाहर विशिष्ट रूप से पंक्तियों की पहचान करने में सक्षम होना आवश्यक है (और यह अक्सर होता है), तो इस उद्देश्य के लिए आपके पास एक अलग कुंजी होनी चाहिए। सावधानी से चुनी गई व्यावसायिक कुंजी काम करेगी, लेकिन विशिष्टता की गारंटी के लिए आप अक्सर बड़ी संख्या में स्तंभों की स्थिति में आ जाएंगे। एक अन्य तकनीक यह है कि एक आईडी कॉलम को ऑटो-इन्क्रीमेंट क्लस्टर्ड प्राइमरी-की के रूप में और एक अन्य यूनीक आइडेंटिफायर (गाइड) कॉलम को गैर-क्लस्टर्ड यूनिक की के रूप में, जहां भी यह दुनिया में मौजूद है, वहां विशिष्ट रूप से पंक्ति की पहचान करने के उद्देश्य से है। इस मामले में आपके पास अभी भी एक ऑटो-इंक्रिमेंटेड कुंजी है, क्योंकि यह ऑटो-इंक्रीमेंटिंग कुंजी को क्लस्टर और इंडेक्स करने के लिए एक गाइड के समान करने के लिए अधिक कुशल है।

एक मामला जहां आप एक ऑटो-इंक्रीमेंटिंग कुंजी नहीं चाहते हैं, वह कई-से-कई तालिका होगी जहां प्राथमिक कुंजी दो अन्य तालिकाओं के आईडी कॉलम का एक यौगिक है (आपके पास अभी भी एक ऑटो-इंक्रिमेंटिंग कुंजी हो सकती है, लेकिन मैं इसका सार नहीं देखें)।

एक अन्य प्रश्न ऑटो-इंक्रिमेंटेड कुंजी का डेटाटाइप है। एक इंट 32 का उपयोग करने से आपको मूल्यों की एक बड़ी, लेकिन अपेक्षाकृत सीमित सीमा मिलती है। व्यक्तिगत रूप से मैं अक्सर आईडी के लिए बड़े कॉलम का उपयोग करता हूं, ताकि व्यावहारिक रूप से मूल्यों से बाहर निकलने के बारे में चिंता करने की आवश्यकता न हो।

जैसा कि अन्य लोगों ने वृद्धिशील प्राथमिक कुंजी के लिए मामला बनाया है, मैं एक GUID के लिए एक बनाउंगा:

  • यह अद्वितीय होने की गारंटी है
  • आप अपने आवेदन में डेटा के लिए डेटाबेस की एक कम यात्रा कर सकते हैं। (उदाहरण के लिए एक प्रकार की तालिका के लिए आप एप्लिकेशन में GUID को स्टोर कर सकते हैं और रिकॉर्ड को पुनः प्राप्त करने के लिए इसका उपयोग कर सकते हैं। यदि आप किसी पहचान का उपयोग करते हैं तो आपको नाम से डेटाबेस को क्वेरी करने की आवश्यकता होती है और मैंने कई एप्लिकेशन देखे हैं जो पीके प्राप्त करने के लिए ऐसा करते हैं। और बाद में पूरा विवरण प्राप्त करने के लिए फिर से पूछताछ करता है)।
  • यह डेटा छिपाने के लिए उपयोगी है। www.domain.com/Article/2 मुझे बताएं कि आपके पास केवल दो लेख हैं जबकि www.domain.com/article/b08a91c5-67fc-449f-8a50-ffdf2403444a मुझे कुछ नहीं बताता।
  • आप विभिन्न डेटाबेस से रिकॉर्ड आसानी से मर्ज कर सकते हैं।
  • MSFT पहचान के लिए GUIDS का उपयोग करता है।

अच्छे डिजाइन के सिद्धांत के रूप में, प्रत्येक तालिका में एक पंक्ति को विशिष्ट रूप से पहचानने का एक विश्वसनीय तरीका होना चाहिए। यद्यपि प्राथमिक कुंजी यही है, इसके लिए हमेशा प्राथमिक कुंजी के अस्तित्व की आवश्यकता नहीं होती है। प्रत्येक तालिका में प्राथमिक कुंजी जोड़ना एक बुरा अभ्यास नहीं है क्योंकि यह अद्वितीय पंक्ति पहचान प्रदान करता है, लेकिन यह अनावश्यक हो सकता है।

दो या दो से अधिक तालिकाओं की पंक्तियों के बीच विश्वसनीय संबंध बनाए रखने के लिए, आपको इसे विदेशी कुंजियों के माध्यम से करने की आवश्यकता होती है, इसलिए कम से कम कुछ तालिकाओं में प्राथमिक कुंजी की आवश्यकता होती है। प्रत्येक तालिका में प्राथमिक कुंजी जोड़ने से मौजूदा डेटा में नई तालिकाएँ या संबंध जोड़ने का समय आने पर आपके डेटाबेस डिज़ाइन का विस्तार करना आसान हो जाता है। आगे की योजना बनाना हमेशा अच्छी बात है।

एक बुनियादी सिद्धांत (शायद कठिन नियम) के रूप में, प्राथमिक कुंजी का मान अपनी पंक्ति के पूरे जीवन में कभी नहीं बदलना चाहिए। यह मान लेना बुद्धिमानी है कि एक पंक्ति में कोई भी व्यावसायिक डेटा अपने जीवनकाल में परिवर्तन के अधीन है, इसलिए कोई भी व्यावसायिक डेटा प्राथमिक कुंजी के लिए खराब उम्मीदवार होगा। यही कारण है कि एक ऑटो-इंक्रिमेंटेड पूर्णांक की तरह कुछ सार अक्सर एक अच्छा विचार होता है। हालाँकि, स्वतः-वृद्धि वाले पूर्णांकों की अपनी सीमाएँ होती हैं।

यदि आपके डेटा में केवल आपके डेटाबेस के भीतर ही जीवन होगा, तो स्वतः-वृद्धि वाले पूर्णांक ठीक हैं। लेकिन, जैसा कि अन्य उत्तरों में उल्लेख किया गया है, यदि आप कभी भी अपने डेटा को साझा करना चाहते हैं, सिंक्रनाइज़ करना चाहते हैं, या अन्यथा आपके डेटाबेस के बाहर जीवन है, तो स्वत: वृद्धि वाले पूर्णांक खराब प्राथमिक कुंजी बनाते हैं। एक बेहतर विकल्प एक गाइड (उर्फ यूयूआईडी "सार्वभौमिक अद्वितीय आईडी") होगा।

प्रश्न, और कई उत्तर, महत्वपूर्ण बिंदु को याद करते हैं कि प्रत्येक तालिका के लिए सभी प्राकृतिक कुंजियाँ पूरी तरह से रहती हैं तार्किक योजना डेटाबेस के लिए, और प्रत्येक तालिका के लिए सभी सरोगेट कुंजियाँ पूरी तरह से रहती हैं भौतिक योजना डेटाबेस के लिए। अन्य उत्तर केवल पूर्णांक बनाम GUID सरोगेट कुंजियों के सापेक्ष लाभों पर चर्चा करते हैं, उन कारणों पर चर्चा किए बिना कि सरोगेट कुंजियों का ठीक से उपयोग क्यों किया जाता है, और कब।

बीटीडब्ल्यू: आइए हम गलत परिभाषित और सटीक शब्द के उपयोग से बचें प्राथमिक कुंजी. यह प्री-रिलेशनल डेटा मॉडल का एक आर्टिफैक्ट है जिसे पहले रिलेशनल मॉडल में सह-चुना गया था, और फिर विभिन्न आरडीबीएमएस विक्रेताओं द्वारा भौतिक डोमेन में वापस सह-चुना गया। इसका उपयोग केवल शब्दार्थ को भ्रमित करने का कार्य करता है।

से नोट संबंधपरक मॉडल कि, डेटाबेस के लिए तार्किक योजना में होना पहला सामान्य रूप, प्रत्येक तालिका में एक होना चाहिए फ़ील्ड का उपयोगकर्ता-दृश्यमान सेट, जिसे a . के रूप में जाना जाता है प्राकृतिक कुंजी, जो विशिष्ट रूप से तालिका की प्रत्येक पंक्ति की पहचान करता है। ज्यादातर मामलों में इस तरह की प्राकृतिक कुंजी को आसानी से पहचाना जाता है, लेकिन कभी-कभी एक का निर्माण किया जाना चाहिए, चाहे वह a टाई ब्रेकर क्षेत्र या अन्यथा। हालाँकि ऐसी निर्मित कुंजी हमेशा उपयोगकर्ता को दिखाई देती है, और इस प्रकार हमेशा रहती है तार्किक योजना डेटाबेस का।

इसके विपरीत कोई भी सरोगेट कुंजी एक मेज पर विशुद्ध रूप से रहता है भौतिक योजना डेटाबेस के लिए (और इस प्रकार हमेशा सुरक्षा कारणों से और डेटाबेस अखंडता के रखरखाव के लिए, डेटाबेस उपयोगकर्ताओं के लिए पूरी तरह से अदृश्य होना चाहिए)। a को पेश करने का एकमात्र कारण सरोगेट कुंजी में प्रदर्शन के मुद्दों को संबोधित करना है भौतिक रखरखाव और उपयोग डीबी के चाहे वे शामिल हों, प्रतिकृति, डेटा के लिए कई हार्डवेयर स्रोत, या अन्य।

चूंकि सरोगेट कुंजी की शुरुआत का एकमात्र कारण प्रदर्शन है, आइए मान लें कि हम चाहते हैं कि यह प्रदर्शनकारी हो। यदि हाथ में प्रदर्शन समस्या शामिल है, तो हम अनिवार्य रूप से अपनी सरोगेट कुंजी को जितना हो सके संकीर्ण बनाना चाहते हैं (हार्डवेयर के रास्ते में आए बिना, इसलिए छोटे पूर्णांक और बाइट आमतौर पर बाहर होते हैं)। प्रदर्शन में शामिल हों न्यूनतम सूचकांक ऊंचाई पर निर्भर करता है, इसलिए 4-बाइट पूर्णांक एक प्राकृतिक समाधान है। यदि आपकी प्रदर्शन समस्या प्रविष्टि दर है तो 4-बाइट पूर्णांक भी एक प्राकृतिक समाधान हो सकता है (आपके आरडीबीएमएस के आंतरिक के आधार पर)। यदि किसी तालिका के लिए आपकी प्रदर्शन समस्या किसी अन्य की तुलना में प्रतिकृति या एकाधिक डेटा स्रोत है सरोगेट कुंजी प्रौद्योगिकी, चाहे वह GUID हो या दो-भाग कुंजी (होस्ट आईडी + पूर्णांक) अधिक उपयुक्त हो सकती है। मैं व्यक्तिगत रूप से GUID का पसंदीदा नहीं हूं लेकिन वे सुविधाजनक हैं।

संक्षेप में, सभी तालिकाओं के लिए a . की आवश्यकता नहीं होगी सरोगेट कुंजी (किसी भी प्रकार का) उनका उपयोग केवल तभी किया जाना चाहिए जब विचाराधीन तालिका के प्रदर्शन के लिए आवश्यक समझा जाए। चाहे जो भी आम सरोगेट कुंजी अपनी पसंद की तकनीक, विकल्प बदलने से पहले तालिका की वास्तविक जरूरतों के बारे में ध्यान से सोचें needs सरोगेट कुंजी एक मेज के लिए प्रौद्योगिकी विकल्प थकाऊ काम होगा। अपनी तालिका के लिए प्रमुख प्रदर्शन मीट्रिक का दस्तावेजीकरण करें ताकि आपके उत्तराधिकारी किए गए विकल्पों को समझ सकें।

विशेष स्थितियां

यदि आपकी व्यावसायिक आवश्यकताओं में उस क्षेत्र की तुलना में ऑडिट (या अन्य) उद्देश्यों के लिए लेनदेन की अनुक्रमिक संख्या अनिवार्य है नहीं एक सरोगेट कुंजी यह एक है प्राकृतिक कुंजी (अतिरिक्त आवश्यकताओं के साथ)। दस्तावेज़ीकरण से एक ऑटो-इंक्रीमेंटिंग पूर्णांक केवल उत्पन्न होता है सरोगेट कुंजियाँ, इसलिए इसे उत्पन्न करने के लिए कोई अन्य तंत्र खोजें। Obviously some sort of monitor will be necessary, and if you are sourcing your transactions from multiple sites then one site will be special, by virtue of being the designated host site for the monitor.

If your table will never be more than about a hundred rows then index height is irrelevant every access will be by a table scan. However string comparisons on long strings will still be much more expensive than comparison of a 4-byte integer, and more expensive than comparison of a GUID.

A table of कोड values keyed by a char(4) कोड field should be as performant as one with a 4-byte integer. Although I have no proof of this I use the assumption frequently and have never had reason to rue it.


Creating a table with auto-incrementing IDs in a SQL query

If you’re starting from scratch, you’ll need to create a table in your database that’s set up to auto-increment its primary keys.

➞ PostgreSQL

When creating an auto-incremented primary key in Postgres, you’ll need to use SERIAL to generate sequential unique IDs. Default start and increment are set to 1.

When applied to our example inventory data set, table creation looks like:

This first step is pretty straightforward. Just be sure to mark your item number column as the PRIMARY KEY .

Auto-incrementing in MySQL is pretty similar to SQL Server, except you don’t manually include the starting value and integer value. Instead, you use the AUTO_INCREMENT keyword, which has a default start and increment value of 1.

The basic syntax for creating this table in MySQL is:

In our example, here’s the table we’d want to create:

Like Postgres, you need to make sure that you’re using the PRIMARY KEY keyword for the column you want to generate your unique IDs from.

➞ SQL Server

In SQL Server, you’ll use the IDENTITY keyword to set your primary key (or item_number in our use case). By default, the starting value of IDENTITY is 1, and it will increment by 1 with each new entry unless you tell it otherwise.

To start, create a table. The basic syntax:

When applied to our inventory test case, table creation will look like:

Again—one last time—make sure to include PRIMARY KEY next to the SERIAL keyword, so you’re not just generating a useless list of sequential numbers.

Now, once you’ve created the framework of your table, you’ll need to decide if the default starting and increment values make sense for your use case.

Subscribe to the Retool monthly newsletter
Once a month we send out top stories (like this one) along with Retool tutorials, templates, and product releases.


६ उत्तर ६

You could use a CAML query and sort by the particular field, grab the highest value and add one. Should probably have a distinct check as well.

The query can be something like this :

I don't think your approach or the idea of performing a CAML query would work (. at least not consistently), primarily due to your inability to natively manage concurrency. It would be challenging enough to handle it in a single WFE environment, but if you have multiple WFEs you would most assuredly have multiple instances of an event receiver or query executing at the same time, returning the same "last ID" value and then all setting their LogIDNumber property to the same last+1 value.

I suppose you could create an ID list with one column (LogIDNumber), make it a Number type, and make sure Enforce unique values = Yes. You can then add an item to that list in your event receiver and if it chokes then you know another EV instance got there first and you need to requery the last ID until the insert into the ID list doesn't choke. If it doesn't choke then your EV instance owns the ID and can safely update the LogIDNumber property for that list item.

Can I ask what requirement(s) are causing you to create your own auto-icrement column versus using ID?


I had a similar issue, I solved it and since this comes up high on Google for what I was looking for it may help others.

I migrated several Wordpress databases from AWS RDS MySQL to MySQL running on an EC2 instance, using the database migration service. What I didn't know is it doesn't copy indexes, keys, auto increment, or really anything other than the basics. Of course the best approach would be to dump the database using mysqldump and import it manually, but one Wordpress install had significant changes and I didn't want to redo them. Instead I manually recreated the auto_increment values and indexes.

I've documented how I fixed Wordpress auto increment here on my website, here's a copy of what worked for me. It's possible I'll make further changes, I'll update the website but I may not remember to update this question.

  • You should check your tables and make sure to set your auto_increment to a value that makes sense for that table.
  • If you get the error “alter table causes auto_increment resequencing resulting in duplicate entry 1” (or 0, or something else). This is usually fixed by deleting the entry with the ID 0 or 1 in the table. Note that you should be careful doing this as it could delete an important row.

Why did this happen? Here's what went wrong for me:

If you exported your database using phpadmin and had an error on reimporting it, the code that adds the primary key doesn't run because it's at the end of the SQL file, not at its creation.

Before I figured this out, I updated to the phpmyadmin 5 beta and it imported the files with the key even though I still had the error.

Lesson one is, don't let your import crash, even if your tables are there. Mine crashed on table that began with wp_w so it came after user and rekt my auto increments.

If you look at the bottom of your SQL export, you will find the alter table for adding the Primary Key and the auto increment.

You don't need to specify the auto increment it automatically knows what the next increment is like so:

If you had admin activity since this happened, you have zeros in your key field, which will not allow you to set a primary key, and without that, you can't auto increment. So you need to run a delete script vs each table like so:

Here's a complete set of updates If your table has these, it will throw and error.


4 उत्तर 4

Tim, I had faced the same issue where I needed to restart the identity to the next value. I was using db2v9.1.

Unfortunately, there is no way to specify the next value automatically. As per DB2 documentation the value should be a 'numeric constant'. Hence I had to do a select max(id), get the value and replace it in the alter..restart stmt manually.

I don't remember if I tried this - but you can write an sp where max(id) is set in a variable and assign the variable in the alter. restart stmt. (I am unable to try as I dont hav access to any db2 database anymore). I doubt it'll work though. (If it works do let me know :))

DB2 reference:

RESTART or RESTART WITH numeric-constant

Resets the state of the sequence associated with the identity column. If WITH numeric-constant is not specified, the sequence for the identity column is restarted at the value that was specified, either implicitly or explicitly, as the starting value when the identity column was originally created. The column must exist in the specified table (SQLSTATE 42703), and must already be defined with the IDENTITY attribute (SQLSTATE 42837). RESTART does not change the original START WITH value.

The numeric-constant is an exact numeric constant that can be any positive or negative value that could be assigned to this column (SQLSTATE 42815), without non-zero digits existing to the right of the decimal point (SQLSTATE 428FA). The numeric-constant will be used as the next value for the column.


Frequently, we happen to need to fill tables with unique identifiers. Naturally, the first example of such identifiers is PRIMARY KEY data. These are usually integer values hidden from the user since their specific values are unimportant.

When adding a row to a table, you need to take this new key value from somewhere. You can set up your own process of generating a new identifier, but MySQL comes to the aid of the user with the AUTO_INCREMENT column setting. It is set as a column attribute and allows you to generate unique integer identifiers. As an example, consider the users table, the primary key includes an id column of type INT:

Inserting a NULL value into the id field leads to the generation of a unique value inserting 0 value is also possible unless the NO_AUTO_VALUE_ON_ZERO Server SQL Mode is enabled::

It is possible to omit the id column. The same result is obtained with:

The selection will provide the following result:

Select from users table shown in dbForge Studio

You can get the automatically generated value using the LAST_INSERT_ID() session function. This value can be used to insert a new row into a related table.

There are aspects to consider when using AUTO_INCREMENT, here are some:

  • In the case of rollback of a data insertion transaction, no data will be added to a table. However, the AUTO_INCREMENT counter will increase, and the next time you insert a row in the table, holes will appear in the table.
  • In the case of multiple data inserts with a single INSERT command, the LAST_INSERT_ID() function will return an automatically generated value for the first row.
  • The problem with the AUTO_INCREMENT counter value is described in Bug #199 – Innodb autoincrement stats los on restart.

For example, let’s consider several cases of using AUTO_INCREMENT for table1 :

ध्यान दें: The next AUTO_INCREMENT value for the table can be parsed from the SHOW CREATE TABLE result or read from the AUTO_INCREMENT field of the INFORMATION_SCHEMA TABLES table.

The rarer case is when the primary key is surrogate — it consists of two columns. MyISAM engine has an interesting solution that provides the possibility of generating values for such keys. Let’s consider the example:

It is quite a convenient solution:

Special values auto generation

The possibilities of the AUTO_INCREMENT attribute are limited because it can be used only for generating simple integer values. But what about complex identifier values? For example, depending on the date/time or [A0001, A0002, B0150…]). To be sure, such values should not be used in primary keys, but they might be used for some auxiliary identifiers.

The generation of such unique values can be automated, but it will be necessary to write code for such purposes. We can use the BEFORE INSERT trigger to perform the actions we need.

Let’s consider a simple example. We have the sensors table for sensors registration. Each sensor in the table has its own name, location, and type: 1 –analog, 2 –discrete, 3 –valve. Moreover, each sensor should be marked with a unique label like [symbolic representation of the sensor type + a unique 4-digit number] where the symbolic representation corresponds to such values [AN, DS, VL].

In our case, it is necessary to form values like these [DS0001, DS0002…] and insert them into the label column.

When the trigger is executed, it is necessary to understand if any sensors of this type exist in the table. It is enough to assign number “1” to the first sensor of a certain type when it is added to the table.

In case such sensors already exist, it is necessary to find the maximum value of the identifier in this group and form a new one by incrementing the value by 1. Naturally, it is necessary to take into account that the label should start with the desired symbol and the number should be 4-digit.


३ उत्तर ३

Why are you creating something that SharePoint already does?

You can use the SharePoint default column ID in Workflows (as mentioned in the comments of the blogpost you refer to)

ID gets assigned के पश्चात a New Item is created, so you can not use it in Calculated Column Formulas.

But Workflows are executed after the List Item is created so you can use ID in your workflow.

Only drawback might be, ID can not easily be reset, it will always increment

My new workflow is here here is working perfectly for me.

Event Handler approach can be used also for Autonumbering if you are in programming but I haven't tested it!

I'm trying to think of an alternate solution, but it seems you'll need to use a set of If conditions in the solution - that's if you want the preceding 000 prior to the ID value.

The workflow checks if the ID or the Next Number variable is within a certain range, and then append CaseOPT and the correct number of zeroes prior to the ID value.

Edit: The workflow would look something like this:

This is using the format "CaseOPT####" as the unique id.

I've arranged it this way assuming most of your entries will be in the 1000 - 100 range. Rearrange it depending on how much items you expect and how fast your list grows.


१ उत्तर १

I read that uuid does not bring any security advantages

This entirely relative to a given context. So it's neither true or false.

Consider that right now the session id is encrypting the auto-increment id (no uuid is used). If someone manages to know how the session is encrypted, then he can impersonate all the users: encrypt "1" and set the value as sessionID, encrypts "2" and set the value as sessionID, etc.

Session identifiers work if they're long random pieces of information. They do not encode or encrypt any information, these tokens are used by the server to locate information pertaining the established session.

In a typical scenario, client A connects to server B for the first time. They have no information or session id at this point. Server generates a new session id and sends it to client. Potentially authentication occurs and some data is stored on the server pertaining that particular session. Every subsequent request from the client carries this identifier so that the server can match the data relevant to that particular client during this particular session. Notice the data is stored on the server, all the client does is issue requests of whatever kind and tack on the session identifier as a way to maintain state in a stateless system.

Simultaneously other clients are doing the same. The server can maintain multiple states since every client uses their own unique session identifier. If the sessions weren't random or easily guessable, then an attacker could calculate or guess them and hijack established sessions.

So a randomly generated UUID is no better or worse than a randomly generated session identifier for the same length of random data.


Is it good practice to keep 2 related tables (using auto_increment PK) to have the same Max of auto_increment ID when table1 got modified?

This question is about good design practice in programming.

Let see this example, we have 2 interrelated tables:

rID is auto_increment primary key & textID is foreign key

The relationship is that 1 rID will have 1 and only 1 textID but 1 textID can have a few rID .

So, when table1 got modification then table2 should be updated accordingly.

Ok, here is a fictitious example. You build a very complicated system. When you modify 1 record in table1, you need to keep track of the related record in table2. To keep track, you can do like this:

Option 1: When you modify a record in table1, you will try to modify a related record in table 2. This could be quite hard in term of programming expecially for a very very complicated system.

Option 2: instead of modifying a related record in table2, you decided to delete old record in table 2 & insert new one. This is easier for you to program.

For example, suppose you are using option2, then when you modify record 1,2,3. 100 in table1, the table2 will look like this:

This means the मैक्स of auto_increment IDs in table1 is still the same (100) but the मैक्स of auto_increment IDs in table2 already reached 200.

what if the user modify many times? if they do then the table2 may run out of records? we can use BigInt but that make the app run slower?

Note: If you spend time to program to modify records in table2 when table1 got modified then it will be very hard & thus it will be error prone. But if you just clear the old record & insert new records into table2 then it is much easy to program & thus your program is simpler & less error prone.

So, is it good practice to keep 2 related tables (using auto_increment PK) to have the same Max of auto_increment ID when table1 got modified?