डेटाबेस और एसक्यूएल के बारे में मेरा ज्ञान विश्वविद्यालय की अधिकांश कक्षाओं पर आधारित है। किसी भी तरह, मैंने एक कंपनी में कुछ मठ (लगभग एक वर्ष) बिताए, जहां मैं डेटाबेस के साथ काम कर रहा था।
मैं कुछ किताबें पढ़ लिया है और मैं इस तरह के रूप डेटाबेस के बारे में कुछ प्रशिक्षण में भाग लिया है MySQL, PostgreSQL, SQLite, Oracleऔर भी कुछ nonSQL dbजैसे हमें MongoDB, Redis, ElasticSearchआदि
साथ ही मैंने कहा, मैं ज्ञान की कमी के साथ भीख माँगता हूँ, लेकिन आज, किसी ने कुछ बताया, जो मेरे भिखारी के ज्ञान के खिलाफ है।
मुझे समझाने दो। चलो SQL डेटाबेस लेते हैं और Personअंदर कुछ रिकॉर्ड के साथ सरल तालिका बनाते हैं :
id | name | age
-----------------
1 | Alex | 24
2 | Brad | 34
3 | Chris | 29
4 | David | 28
5 | Eric | 18
6 | Fred | 42
7 | Greg | 65
8 | Hubert | 53
9 | Irvin | 17
10 | John | 19
11 | Karl | 23अब, यह हिस्सा है, मैं इस पर ध्यान केंद्रित करना चाहूंगा - idहै INDEX।
अब तक, मैंने सोचा था कि यह इस तरह से काम करता है: जब एक तालिका बनाई जा रही INDEXहै तो खाली है। जब मैं अपनी तालिका में नया रिकॉर्ड जोड़ रहा हूं तो INDEXकुछ alghortims के आधार पर पुनर्गणना की जा रही है। उदाहरण के लिए:
एक के बाद एक समूह बनाना:
1 ... N
N+1 ... 2N
...
XN+1 ... (X+1)Nइसलिए, मेरे उदाहरण के लिए size = 11 elementsऔर N = 3यह इस तरह होगा:
id | name | age
-----------------
1 | Alex | 24 // group0
2 | Brad | 34 // group0
3 | Chris | 29 // group0
4 | David | 28 // group1
5 | Eric | 18 // group1
6 | Fred | 42 // group1
7 | Greg | 65 // group2
8 | Hubert | 53 // group2
9 | Irvin | 17 // group2
10 | John | 19 // group3
11 | Karl | 23 // group3इसलिए, जब मैं क्वेरी का उपयोग कर रहा हूं तो SELECT * FROM Person WHERE id = 8यह कुछ सरल गणना करेगा 8 / 3 = 2, इसलिए हमें इस ऑब्जेक्ट को देखना group2होगा और फिर यह पंक्ति वापस आ जाएगी:
8 | Hubert | 53
यह दृष्टिकोण उस समय में काम करता है O(k)जहां k << size। बेशक, समूहों में पंक्तियों को व्यवस्थित करने के लिए एक अलगता निश्चित रूप से अधिक जटिल है, लेकिन मुझे लगता है कि यह सरल उदाहरण मेरी बात को दर्शाता है।
इसलिए अब, मैं एक और दृष्टिकोण प्रस्तुत करना चाहूंगा, जो आज मुझे दिखाया गया है।
आइए एक बार फिर से इस तालिका को लें:
id | name | age
-----------------
1 | Alex | 24
2 | Brad | 34
3 | Chris | 29
4 | David | 28
5 | Eric | 18
6 | Fred | 42
7 | Greg | 65
8 | Hubert | 53
9 | Irvin | 17
10 | John | 19
11 | Karl | 23अब, हम Hashmap(वास्तव में, यह हैश मैप है) के समान कुछ बना रहे हैं , जो इस आईडी के साथ पंक्ति में मैप idकरता addressहै। हम कहते हैं:
id | addr
---------
1 | @0001
2 | @0010
3 | @0011
4 | @0100
5 | @0101
6 | @0110
7 | @0111
8 | @1000
9 | @1001
10 | @1010
11 | @1011इसलिए अब, जब मैं अपनी क्वेरी चला रहा हूं: SELECT * FROM Person WHERE id = 8
यह सीधे id = 8मेमोरी में पता करने के लिए मैप करेगा और पंक्ति वापस आ जाएगी। बेशक इसकी जटिलता है O(1)।
इसलिए अब, मुझे कुछ प्रश्न मिले हैं।
1. दोनों समाधानों के रोमांच और अव्यवस्थाएं क्या हैं?
2. वर्तमान डेटाबेस कार्यान्वयन में कौन अधिक लोकप्रिय है? शायद अलग-अलग डीबीएस अलग-अलग तरीकों का उपयोग करते हैं?
3. क्या यह nonSQL dbs में मौजूद है?
पहले ही, आपका बहुत धन्यवाद
तुलना
| B-tree | Hash Table
----------------------------------------------------
---------------- one element -------------------
----------------------------------------------------
SEARCHING | O(log(N)) | O(1) -> O(N)
DELETING | O(log(N)) | O(1) -> O(N)
INSERTING | O(log(N)) | O(1) -> O(N)
SPACE | O(N) | O(N)
----------------------------------------------------
---------------- k elements -------------------
----------------------------------------------------
SEARCHING | k + O(log(N)) | k * O(1) -> k * O(N)
DELETING | k + O(log(N)) | k * O(1) -> k * O(N)
INSERTING | k + O(log(N)) | k * O(1) -> k * O(N)
SPACE | O(N) | O(N)एन - रिकॉर्ड की संख्या
क्या मैं सही हू? प्रत्येक डालने / हटाने के बाद बी-ट्री और हैश टेबल के पुनर्निर्माण की लागत के बारे में क्या ? बी-ट्री के मामले में हमें कुछ संकेत बदलने होंगे लेकिन संतुलित बी-ट्री के मामले में इसे और अधिक प्रयास की आवश्यकता है। साथ ही हैश टेबल के मामले में हमें कुछ ऑपरेशन करने होंगे, खासकर, अगर हमारे ऑपरेशन में टकराव उत्पन्न होता है ।
Of course, an alghoritm to organise rows in groups is for sure much more complicated but I think this simple example shows my point of view.बेशक, मुझे पता है कि यह बहुत अधिक जटिल है। तो आखिरकार, जब मैं अपने कोड में कह रहा हूं कि मेरा INDEXकौन सा समाधान ( पहला या दूसरा ) इस वास्तविक के करीब है? और समय के आधार पर रिकॉर्ड तक पहुंचने के लिए क्या आवश्यक था INDEX। क्या यह वास्तव में है O(1)? बी-ट्री इंडेक्स के साथ यह बहुत अच्छा लगता है O(log2(N))। क्या मैं सही हू?
O(1)यह सही है! पहले तरीके से, ऐसा लगता है कि आप बी-ट्री इंडेक्स का वर्णन कर रहे हैं लेकिन आपको कुछ गलतफहमी है। कोई गणना नहीं है (3 या कुछ भी विभाजन), यह अधिक जटिल है क्योंकि पेड़ में अधिक स्तर हैं (यह एक पेड़ है, इसकी बड़ी, छोटी, छोटी शाखाएं हैं ..., और फिर छोड़ देता है :)