डेटाबेस में फिर से क्रमबद्ध सूची संग्रहीत करना

Question

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

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

मैंने लोगों को पिछले (या अगले) मान को संदर्भित करने के लिए एक स्व-संदर्भ का उपयोग करते हुए देखा है, लेकिन फिर से, ऐसा लगता है कि आपको सूची में कई अन्य मदों को अपडेट करना होगा।

एक अन्य समाधान जो मैंने देखा है वह दशमलव संख्याओं और उनके बीच के अंतराल में केवल वस्तुओं को चिपकाने का उपयोग कर रहा है, जो कि अब तक का सबसे अच्छा समाधान है, लेकिन मुझे यकीन है कि एक बेहतर तरीका होना चाहिए।

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

क्या किसी के पास कोई विचार है?

किसी भी मदद के लिए चीयर्स!

Comments

क्या आप थोड़ा सा बेंचमार्किंग कर सकते हैं और हमें बता सकते हैं कि क्या IO या डेटाबेस एक अड़चन होगी?

— रवांग

पर संबंधित सवाल stackoverflow ।

— जोर्डो

स्व-संदर्भ के साथ, सूची में एक स्थान से दूसरे स्थान पर एक वस्तु को ले जाने पर आपको केवल 2 आइटम अपडेट करने होंगे। देखें en.wikipedia.org/wiki/Linked_list

— पीटर बी

हम्म, यह सुनिश्चित नहीं है कि लिंक की गई सूचियों को उत्तरों में शायद ही कोई ध्यान आ रहा है।

— क्रिस्टियान वेस्टरबेक

Answer 1

सबसे पहले, दशमलव संख्याओं के साथ कुछ भी करने की कोशिश मत करो, क्योंकि वे तुम्हें उगल देंगे। REALऔर DOUBLE PRECISIONनिष्प्रभावी हैं और आप उनमें जो डालते हैं उसका ठीक से प्रतिनिधित्व नहीं कर सकते हैं। NUMERICसटीक है, लेकिन चालों का सही क्रम आपको सटीक रूप से चलाएगा और आपका कार्यान्वयन बुरी तरह से टूट जाएगा।

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

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

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

Comments

यह ठीक उसी तरह है जैसे मैंने इसे एक परियोजना बोली तैयारी प्रणाली में संभाला था जो हमारे पास वर्षों पहले एक गजिलियन था। एक्सेस में भी, अपडेट तेजी से विभाजित था।

— एचएलजीईएम

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

— टॉम ब्रूनोली

@TomBrunoli: मुझे यह सुनिश्चित करने के लिए कहने से पहले कार्यान्वयन पर थोड़ा सोचना होगा, लेकिन आप ट्रिगर के साथ ऑटोमैटिक रूप से रीन्युबेरिंग के अधिकांश या सभी को खींचने में सक्षम हो सकते हैं। उदाहरण के लिए, यदि आप आइटम 7 को हटाते हैं, तो ट्रिगर एक ही सूची में सभी पंक्तियों को हटाता है, जो हटाने के बाद 7 से अधिक हो जाती है। आवेषण एक ही काम करेगा (एक आइटम 7 को सम्मिलित करना सभी पंक्तियों को 7 या अधिक बढ़ाना होगा)। एक अद्यतन के लिए ट्रिगर (जैसे, 9 और 10 के बीच आइटम 3 को स्थानांतरित करें) मध्यम रूप से अधिक जटिल होगा लेकिन निश्चित रूप से संभव के दायरे में है।

— Blrfl

मैंने वास्तव में इससे पहले ट्रिगर्स में नहीं देखा था, लेकिन ऐसा करने का एक अच्छा तरीका लगता है।

— टॉम ब्रूनोली

@TomBrunoli: यह मेरे लिए होता है कि ऐसा करने के लिए ट्रिगर का उपयोग करने से कैस्केड हो सकता है। लेन-देन में सभी परिवर्तनों के साथ संग्रहीत प्रक्रियाएं इसके लिए बेहतर मार्ग हो सकती हैं।

— ब्लरफ्ल

Answer 2

यहाँ से समान जवाब https://stackoverflow.com/a/49956113/10608

---

समाधान: indexएक स्ट्रिंग करें (क्योंकि तार, संक्षेप में, अनंत "मनमाना परिशुद्धता" है)। या यदि आप index1 के बजाय 100 से बढ़ाकर एक इंट्री का उपयोग करते हैं ।

प्रदर्शन समस्या यह है: दो सॉर्ट किए गए आइटमों के बीच "मूल्यों के बीच" नहीं है।

item      index
-----------------
gizmo     1
              <<------ Oh no! no room between 1 and 2.
                       This requires incrementing _every_ item after it
gadget    2
gear      3
toolkit   4
box       5

इसके बजाय, इस तरह करें (नीचे बेहतर समाधान):

item      index
-----------------
gizmo     100
              <<------ Sweet :). I can re-order 99 (!) items here
                       without having to change anything else
gadget    200
gear      300
toolkit   400
box       500

इससे भी बेहतर: यहाँ बताया गया है कि कैसे जीरा इस समस्या को हल करता है। उनका "रैंक" (जिसे आप इंडेक्स कहते हैं) एक स्ट्रिंग मान है जो रैंक की गई वस्तुओं के बीच में एक टन श्वास लेने की अनुमति देता है।

यहाँ एक जीरा डेटाबेस का एक वास्तविक उदाहरण है जिसके साथ मैं काम करता हूँ

   id    | jira_rank
---------+------------
 AP-2405 | 0|hzztxk:
 ES-213  | 0|hzztxs:
 AP-2660 | 0|hzztzc:
 AP-2688 | 0|hzztzk:
 AP-2643 | 0|hzztzs:
 AP-2208 | 0|hzztzw:
 AP-2700 | 0|hzztzy:
 AP-2702 | 0|hzztzz:
 AP-2411 | 0|hzztzz:i
 AP-2440 | 0|hzztzz:r

इस उदाहरण को देखें hzztzz:i। एक स्ट्रिंग रैंक के लाभ यह है कि आप दो आइटम के बीच कमरे से बाहर चलाने के लिए, आप है अभी भी रैंक फिर से कुछ और नहीं है। आप बस फ़ोकस को कम करने के लिए स्ट्रिंग में अधिक वर्ण जोड़ना शुरू करते हैं।

Comments

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

— एनएसजोनस

Answer 3

मैंने लोगों को पिछले (या अगले) मान को संदर्भित करने के लिए एक स्व-संदर्भ का उपयोग करते हुए देखा है, लेकिन फिर से, ऐसा लगता है कि आपको सूची में कई अन्य मदों को अपडेट करना होगा।

क्यों? मान लें कि आप स्तंभों के साथ एक लिंक-सूची तालिका दृष्टिकोण (listID, itemID, nextItemID) लेते हैं।

एक सूची में एक नया आइटम सम्मिलित करने पर एक प्रविष्टि और एक संशोधित पंक्ति का खर्च आता है।

किसी आइटम को रिपॉजिट करने में तीन पंक्ति संशोधनों (आइटम को ले जाया जा रहा है, इससे पहले आइटम और उसके नए स्थान से पहले आइटम) की लागत होती है।

एक आइटम को हटाने से एक हटाने और एक संशोधित पंक्ति का खर्च होता है।

ये लागत समान है चाहे सूची में 10 आइटम हों या 10,000 आइटम। यदि लक्ष्य पंक्ति पहली सूची आइटम है, तो सभी तीन मामलों में एक कम संशोधन है। यदि आप अधिक बार अंतिम सूची आइटम पर काम कर रहे हैं तो यह अगले के बजाय प्राइमइमिड स्टोर करने के लिए फायदेमंद हो सकता है।

Answer 4

"लेकिन ऐसा लगता है कि यह काफी अक्षम होगा"

क्या आपने नाप लिया ? या यह सिर्फ एक अनुमान है? बिना किसी प्रमाण के ऐसी धारणाएं न बनाएं।

"प्रति सूची 20 से 50 आइटम"

ईमानदारी से, यह "बहुत सारी वस्तुओं" नहीं है, मेरे लिए जो बहुत कम लगता है।

मेरा सुझाव है कि आप "स्थिति स्तंभ" दृष्टिकोण से चिपके रहें (यदि यह आपके लिए सबसे सरल कार्यान्वयन है)। ऐसी छोटी सूची आकारों के लिए, वास्तविक प्रदर्शन समस्याओं का अनुभव करने से पहले अनावश्यक अनुकूलन शुरू न करें

Answer 5

यह वास्तव में पैमाने का सवाल है, और मामले का उपयोग करें ..

एक सूची में आप कितने आइटम की उम्मीद करते हैं? यदि लाखों, मुझे लगता है कि दशमलव मार्ग स्पष्ट है।

यदि 6 तो पूर्णांक पुनर्विक्रय स्पष्ट विकल्प है। s यह भी सवाल है कि सूची या पुनर्व्यवस्थित कैसे है। यदि आप एक ऊपर और नीचे तीर का उपयोग कर रहे हैं (एक समय में एक स्लॉट को ऊपर या नीचे ले जा रहे हैं), तो मैं पूर्णांक का उपयोग करूँगा फिर आगे चलकर (या अगले) स्वैप करना होगा।

इसके अलावा, आप कितनी बार कमिट करते हैं, यदि उपयोगकर्ता 250 बदलाव कर सकता है, तो एक ही बार में कम कर सकता है।

tl; dr: अधिक जानकारी की आवश्यकता है।

---

संपादित करें: "विश लिस्ट्स" बहुत सारी छोटी सूचियों की तरह लगता है (धारणा, यह गलत हो सकती है) .. इसलिए मैं कहता हूं कि इंटीगर को फिर से विकसित करना है। (प्रत्येक सूची में अपना स्वयं का पद शामिल है)

Comments

मैं कुछ और संदर्भ के साथ प्रश्न को अपडेट करूंगा

— टॉम ब्रुनोली

दशमलव काम नहीं करता है, क्योंकि परिशुद्धता सीमित है, और प्रत्येक डाला आइटम संभावित 1 बिट लेता है

— njzk2

Answer 6

यदि उद्देश्य प्रति ऑपरेशन के दौरान डेटाबेस संचालन की संख्या को कम करना है:

ऐसा मानते हुए

• सभी खरीदारी वस्तुओं को 32-बिट पूर्णांक के साथ गणना की जा सकती है।
• उपयोगकर्ता की इच्छा सूची के लिए अधिकतम आकार सीमा है। (मैंने देखा कि कुछ लोकप्रिय वेबसाइट में सीमा के रूप में 20 - 40 आइटम का उपयोग होता है)

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

https://www.postgresql.org/docs/current/static/arrays.html

---

यदि उद्देश्य अलग है, तो "स्थिति कॉलम" दृष्टिकोण के साथ रहें।

---

"गति" के बारे में, संग्रहीत प्रक्रिया दृष्टिकोण को बेंचमार्क करना सुनिश्चित करें। जबकि एक इच्छा सूची फेरबदल के लिए 20+ अलग-अलग अपडेट जारी करना धीमा हो सकता है, संग्रहीत कार्यविधि का उपयोग करने का एक तेज़ तरीका हो सकता है।

Answer 7

ठीक है मैं हाल ही में इस मुश्किल समस्या का सामना कर रहा हूं, और इस प्रश्नोत्तर में सभी जवाबों ने कई प्रेरणा दी। जिस तरह से मैं इसे देखता हूं, प्रत्येक समाधान में इसके पेशेवरों और विपक्ष हैं।

• यदि positionक्षेत्र को अंतराल के बिना अनुक्रमिक होना है, तो आपको मूल रूप से पूरी सूची को फिर से ऑर्डर करना होगा। यह एक O (N) ऑपरेशन है। लाभ यह है कि ग्राहक पक्ष को आदेश प्राप्त करने के लिए किसी विशेष तर्क की आवश्यकता नहीं होगी।

• अगर हम O (N) ऑपरेशन से बचना चाहते हैं, लेकिन STILL एक सटीक अनुक्रम बनाए रखता है, तो दृष्टिकोण में से एक "पिछले या (अगले) मान को संदर्भित करने के लिए" स्वयं-संदर्भ का उपयोग करना है। यह एक पाठ्यपुस्तक से जुड़ा सूची परिदृश्य है। डिजाइन द्वारा, यह "सूची में अन्य मदों की एक पूरी बहुत कुछ नहीं" होगा। हालाँकि, इसके लिए क्लाइंट-साइड (एक वेब सेवा या शायद एक मोबाइल ऐप) की आवश्यकता होती है ताकि ऑर्डर को प्राप्त करने के लिए लिंक-लिस्ट ट्रेशल लॉजिक को लागू किया जा सके।

• कुछ भिन्नता संदर्भ या लिंक की गई सूची का उपयोग नहीं करती है। वे पूरे आदेश को एक आत्म निहित बूँद के रूप में दर्शाते हैं, जैसे कि JSON-array-in-a-string [5,2,1,3,...]; इस तरह के आदेश को फिर एक अलग स्थान पर संग्रहीत किया जाएगा। इस दृष्टिकोण के पास अलग-अलग ऑर्डर ब्लॉब को बनाए रखने के लिए क्लाइंट साइड कोड की आवश्यकता का एक साइड इफेक्ट भी है।

• कई मामलों में, हमें वास्तव में सटीक ऑर्डर स्टोर करने की आवश्यकता नहीं है, हमें बस प्रत्येक रिकॉर्ड के बीच एक रिश्तेदार रैंक बनाए रखने की आवश्यकता है। इसलिए हम अनुक्रमिक रिकॉर्ड के बीच अंतराल की अनुमति दे सकते हैं। भिन्नताओं में शामिल हैं: (1) 100, 200, 300 जैसे अंतराल के साथ पूर्णांक का उपयोग करना ... लेकिन आप जल्दी से अंतराल से बाहर निकलेंगे और फिर पुनर्प्राप्ति प्रक्रिया की आवश्यकता होगी; (2) दशमलव का उपयोग करना जो प्राकृतिक अंतराल के साथ आता है, लेकिन आपको यह तय करने की आवश्यकता होगी कि क्या आप अंततः सटीक सीमा के साथ रह सकते हैं; (3) इस उत्तर में वर्णित स्ट्रिंग-आधारित रैंक का उपयोग करना लेकिन मुश्किल कार्यान्वयन ट्रैप से सावधान रहें ।

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

Answer 8

स्थिति कॉलम के लिए एक फ्लोटिंग पॉइंट नंबर का उपयोग करें।

फिर आप "स्थानांतरित" पंक्ति में केवल स्थिति स्तंभ को बदलते हुए सूची को फिर से व्यवस्थित कर सकते हैं।

मूल रूप से यदि आपका उपयोगकर्ता "लाल" को "ब्लू" के बाद "पीला" करना चाहता है

फिर आपको बस गणना करने की आवश्यकता है

red.position = ((yellow.position - blue.position) / 2) + blue.position

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

आप 1000 के शुरुआती अंतराल के साथ पूर्णांक फ़ील्ड का उपयोग करके इसे लागू कर सकते हैं। इसलिए आपका इंटिग्रल ऑर्ड्रिंग 1000-> नीला, 2000-> पीला, 3000-> लाल होगा। नीले रंग के बाद "चलती" लाल के बाद आपके पास 1000-> नीला, 1500-> लाल, 2000-> पीला होगा।

समस्या यह है कि 1000 के कुछ बड़े प्रारंभिक अंतराल के साथ 10 चाल के रूप में कुछ आपको 1000-> नीले, 1001-puce, 1004-> biege जैसी स्थिति में मिल जाएगा ...... जहाँ आप अब सक्षम नहीं होंगे पूरी सूची को फिर से नंबर के बिना "ब्लू" के बाद कुछ भी सम्मिलित करने के लिए। फ्लोटिंग पॉइंट नंबरों का उपयोग करने से दोनों पदों के बीच हमेशा "आधा" बिंदु रहेगा।

Comments

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

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

— जेम्स एंडरसन

Naysayers के लिए, यह समाधान वास्तव में Trello ( trello.com ) करता है। आपके क्रोम डिबगर खोलें और पहले से json उत्पादन diff / एक पुन: व्यवस्थित करें के बाद (खींचें / एक कार्ड ड्रॉप) और आपको मिल - "pos": 1310719, + "pos": 638975.5। निष्पक्ष होने के लिए, ज्यादातर लोग 4 मिलियन प्रविष्टियों के साथ ट्रेलो सूचियों को नहीं करते हैं, लेकिन उपयोगकर्ता-सॉर्ट करने योग्य सामग्री के लिए ट्रेलो की सूची आकार और उपयोग का मामला बहुत आम है। और कुछ भी उपयोगकर्ता-छांटने के लिए उच्च प्रदर्शन के साथ लगभग कुछ भी नहीं है, इंट बनाम फ्लोट सॉर्टिंग गति इसके लिए मूट है, विशेष रूप से विचार करने वाले डेटाबेस ज्यादातर IO प्रदर्शन से विवश हैं।

— जनक

@PieterB 'क्यों एक 64 बिट पूर्णांक का उपयोग न करें' के लिए, यह ज्यादातर डेवलपर के लिए एर्गोनॉमिक्स है, मैं कहूंगा। आपकी औसत फ़्लोट के लिए लगभग 1.0 </ b> से अधिक गहराई है, इसलिए आप 'स्थिति' कॉलम को 1.0 में डिफ़ॉल्ट कर सकते हैं और 0.5, 0.25, 0.75 को आसानी से दोगुना कर सकते हैं। पूर्णांक के साथ, आपका डिफ़ॉल्ट 2 ^ 30 या तो होना चाहिए, जब आप डिबगिंग कर रहे हों, तो यह सोचना थोड़ा मुश्किल हो जाता है। क्या 4073741824 496359787 से बड़ा है? अंकों की गिनती शुरू करें।

— zelk

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

— zelk