जटिल डेटा तक पहुंचने / हेरफेर करने पर, क्या इसे कई छोटे टुकड़ों या एक बड़े हिस्से में संग्रहीत करना बेहतर है?

Question

मैं एक वेब ऐप बना रहा हूं जो काफी जटिल डेटा में हेरफेर करता है: गिटार टैब।

    As a reference, guitar tabs look like this:
Eb|-------------------------------------------------------------------------|
Bb|-------------------------------------------------------------------------|
Gb|--5-5-5-5----------------------------------------------------------------|
Db|--5-5-5-5--3-3-3-3--7-7-7-7--5-5-5-5--2-2-2-2--3-3-3-3--2-2-2-2--5-5-5-5-|
Ab|--3-3-3-3--3-3-3-3--7-7-7-7--5-5-5-5--2-2-2-2--3-3-3-3--2-2-2-2--5-5-5-5-|
Eb|-----------1-1-1-1--5-5-5-5--3-3-3-3--0-0-0-0--1-1-1-1--0-0-0-0--3-3-3-3-|

क्या इस डेटा को एक बड़े चंक के रूप में संग्रहीत करने के लिए, या इसे तोड़ने या "नोट द्वारा" आधार पर संग्रहीत करने के लिए प्रदर्शन के लिए यह अधिक कुशल होगा?

As a use case:
User changes first chord from:       to:
                         Eb|---   Eb|---
                         Bb|---   Bb|---
                         Gb|--5   Gb|--4
                         Db|--5   Db|--4
                         Ab|--3   Ab|--2
                         Eb|---   Eb|---

अगर मैं इसे एक ब्लॉक के रूप में संग्रहीत करता हूं, तो टैब में हेरफेर करने के लिए कोड को और अधिक जटिल होना होगा। अगर मैं इसे नोट द्वारा संग्रहीत करता हूं, तो डेटाबेस को बहुत अधिक एक्सेस करना होगा। कौन सी विधि अधिक कुशल है? संभावित रूप से, बहुत सारे उपयोगकर्ता डेटा को संशोधित करेंगे। मुझे सबसे अच्छा प्रदर्शन करने वाला वेब ऐप चाहिए। अगर मेरा जवाब बिल्कुल प्रभावित होता है तो मैं MySQL का उपयोग करूंगा।

Comments

किस लिए बेहतर है? अंतरिक्ष की बचत? सीपीयू पावर? आईओ? कुछ और?

— ऊद

वैसे, यह एक वेब ऐप है। बहुत सारे उपयोगकर्ता संभावित रूप से बार-बार डेटा को संशोधित करने जा रहे हैं। मैं बहुत सारे कारकों की कल्पना करता हूँ जैसे कि आप इसका उल्लेख अलग-अलग तरीके से करते हैं। मैं उन बारीकियों से परिचित नहीं हूँ; यह आंशिक रूप से मैं यहाँ क्यों पूछ रहा हूँ।

— गेब विलार्ड

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

— ऊद

क्या आप उन्हें बनाने से पहले डेटाबेस डिज़ाइन नहीं करते हैं? मेरा सवाल एक डेटाबेस डिजाइन करने पर है। किसी की समस्या का निवारण नहीं। मैं अभी तक डिबगिंग चरण में नहीं हूं, और यहां तक ​​कि अगर मैं था, तो स्टैकऑवरफ्लो में जाऊंगा, न कि प्रोग्रामर। प्रति FAQ: प्रोग्रामर एल्गोरिथ्म और डेटा संरचना अवधारणाओं, डिजाइन पैटर्न, सॉफ्टवेयर आर्किटेक्चर, सॉफ्टवेयर इंजीनियरिंग को शामिल करता है ... बाधाओं का निवारण नहीं।

— गेब विलार्ड

+1 बहुत ही रोचक समस्या और अच्छी नौकरी का उदाहरण एक उपयोगी उपयोग मामला है। मेरी इच्छा है कि मेरे पास अब गिटार टैब ऐप विकसित करने के लिए एक अच्छा बहाना था।

— इवान प्लाइस

Answer 1

ऑपरेशन की संख्या दोनों ही तरह से होने जा रही है। आप एक गीत के लिए सभी राग प्राप्त करने के लिए एक क्वेरी करते हैं, फिर आप हर बार एक बदलाव करने के लिए एक अपडेट करते हैं। अंतर वास्तव में अपडेट के आकार में है। ब्लॉक विधि के साथ, आपको कॉर्ड बदलने पर हर बार पूरे गाने को सहेजना होगा । व्यक्तिगत पद्धति के साथ, आपके अपडेट छोटे होंगे, और संभवतः समग्र रूप से अधिक कुशल होंगे, हालांकि अंतर नगण्य हो सकता है।

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

Answer 2

सामान्यतया, सामान्यीकरण कई कारणों से अच्छा है:

1. डेटा का कम दोहराव, एक छोटे से भौतिक डेटाबेस आकार के लिए अग्रणी।
2. बेहतर डेटा अखंडता - आप कुछ आवश्यकताओं को लागू करने के लिए विदेशी कुंजी का उपयोग कर सकते हैं।
3. सरल अपडेट कोड, जिसे आपने पहचाना है।
4. डेटा के सबसेट के लिए अधिक अनुक्रमित पहुंच मार्ग।

नुकसान ( यहाँ अच्छी तरह से वर्णित ) में शामिल हैं:

1. सामान्यीकरण अंतरिक्ष बचाता है, लेकिन अंतरिक्ष सस्ता है।
2. सामान्यीकरण अपडेट को सरल करता है, लेकिन पढ़ता अधिक सामान्य है।
3. कम-सामान्यीकृत स्कीमा के साथ प्रदर्शन आमतौर पर बेहतर होता है।

मैं सुझाव दूंगा कि आप सामान्यीकृत डिज़ाइन के साथ शुरुआत करें, और प्रदर्शन समस्याओं में भाग लेने पर केवल निरूपण पर विचार करें।

Comments

गिटार टैब डेटाबेस के साथ, सादगी, स्थिरता और अखंडता ट्रम्प प्रदर्शन। इसलिए मैं सबसे सरल सामान्यीकृत स्कीमा के साथ जाऊंगा जिसके साथ मैं आ सकता था।

— 9000

Answer 3

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

अगर सब आप की जरूरत के लिए एक विशेष गीत के लिए टैब दिखाने के लिए है, तो आप एक दस्तावेज़ उन्मुख डीबी (MongoDB की तरह) में 6-tuples के बहुत सारे स्टोर उन्हें एक दस्तावेज के रूप में प्राप्त करने में कठिनाई हो सकता है।

RDBMS में, मैं इसे इस तरह तालिका में संग्रहीत करता हूं:

table tab_column (
  song_id integer not null foreign key references song(id),
  ordinal integer not null, -- position in the tabulature
  s1 number(2), -- position on 1st string
  ...
  s6 number(2),
  primary key(song_id, ordinal)
)

RDBMSes सरल प्रश्नों पर अच्छे हैं जैसे कि एक गीत दिखाने के लिए आवश्यक है:

select * from tab_column
where song_id = :song_id
order by ordinal;

का उपयोग करना limitऔर offset, आप एक गीत के कुछ हिस्सों को दिखा सकते हैं।

बाद में tab_columnएक तालिका से लिंक करना आसान होगा जो कॉर्ड्स को सूचीबद्ध करता है, अगर आप कॉर्ड को पहचान सकते हैं।

यह संभवतः सबसे सरल स्कीमा संभव है; मैं इसके साथ शुरू करूँगा।