| डेटा के साथ कार्य करना: संबंधपरक डेटाबेस - _Sketchnote by [@nitya](https://twitter.com/nitya)_ |
संभावना है कि आपने जानकारी संग्रहीत करने के लिए अतीत में एक स्प्रेडशीट का उपयोग किया है। आपके पास पंक्तियों और स्तंभों का एक सेट था, जहाँ पंक्तियों में जानकारी (या डेटा) होती थी, और स्तंभों में जानकारी (कभी-कभी मेटाडेटा कहा जाता है) का वर्णन होता था। तालिकाओं में स्तंभों और पंक्तियों के इस मूल सिद्धांत पर एक संबंधपरक डेटाबेस बनाया गया है, जिससे आप कई तालिकाओं में जानकारी फैला सकते हैं। इससे आप अधिक जटिल डेटा के साथ काम कर सकते हैं, दोहराव से बच सकते हैं, और डेटा को एक्सप्लोर करने के तरीके में लचीलापन रख सकते हैं। आइए एक रिलेशनल डेटाबेस की अवधारणाओं का पता लगाएं।
एक रिलेशनल डेटाबेस में इसकी कोर टेबल होती है। स्प्रैडशीट की तरह ही, तालिका स्तंभों और पंक्तियों का एक संग्रह है। पंक्ति में वह डेटा या जानकारी होती है जिसके साथ हम काम करना चाहते हैं, जैसे किसी शहर का नाम या वर्षा की मात्रा। कॉलम उनके द्वारा संग्रहीत डेटा का वर्णन करते हैं।
आइए शहरों के बारे में जानकारी संग्रहीत करने के लिए एक तालिका शुरू करके अपनी खोज शुरू करें। हम उनके नाम और देश से शुरुआत कर सकते हैं। आप इसे एक टेबल में इस प्रकार स्टोर कर सकते हैं:
| City | Country |
| -------- | ------------- |
| Tokyo | Japan |
| Atlanta | United States |
| Auckland | New Zealand |
ध्यान दें कि **शहर**, **देश** और **जनसंख्या** के कॉलम नाम संग्रहीत किए जा रहे डेटा का वर्णन करते हैं, और प्रत्येक पंक्ति में एक शहर के बारे में जानकारी होती है।
## सिंगल टेबल अप्रोच की कमियां
संभावना है, ऊपर दी गई तालिका आपको अपेक्षाकृत परिचित लगती है। आइए अपने बढ़ते डेटाबेस में कुछ अतिरिक्त डेटा जोड़ना शुरू करें - वार्षिक वर्षा (मिलीमीटर में)। हम वर्ष 2018, 2019 और 2020 पर ध्यान केंद्रित करेंगे। अगर हम इसे टोक्यो के लिए जोड़ते हैं, तो यह कुछ इस तरह दिख सकता है:
| City | Country | Year | Amount |
| ----- | ------- | ---- | ------ |
| Tokyo | Japan | 2020 | 1690 |
| Tokyo | Japan | 2019 | 1874 |
| Tokyo | Japan | 2018 | 1445 |
आप हमारी तालिका के बारे में क्या देखते हैं? आप देख सकते हैं कि हम शहर के नाम और देश को बार-बार दोहरा रहे हैं। इसमें काफी स्टोरेज लग सकता है, और इसकी कई प्रतियां रखने के लिए काफी हद तक अनावश्यक है। आखिरकार, टोक्यो का केवल एक ही नाम है जिसमें हम रुचि रखते हैं।
ठीक है, चलो कुछ और कोशिश करते हैं। आइए प्रत्येक वर्ष के लिए नए कॉलम जोड़ें:
| City | Country | 2018 | 2019 | 2020 |
| -------- | ------------- | ---- | ---- | ---- |
| Tokyo | Japan | 1445 | 1874 | 1690 |
| Atlanta | United States | 1779 | 1111 | 1683 |
| Auckland | New Zealand | 1386 | 942 | 1176 |
हालांकि यह पंक्ति दोहराव से बचा जाता है, लेकिन यह कुछ अन्य चुनौतियों को भी जोड़ता है। हर बार नया साल आने पर हमें अपनी तालिका की संरचना को संशोधित करने की आवश्यकता होगी। इसके अतिरिक्त, जैसे-जैसे हमारा डेटा बढ़ता है, वैसे-वैसे हमारे वर्षों में कॉलम के रूप में मूल्यों को पुनः प्राप्त करना और गणना करना मुश्किल हो जाएगा।
यही कारण है कि हमें कई तालिकाओं और संबंधों की आवश्यकता है। अपने डेटा को अलग करके हम दोहराव से बच सकते हैं और हम अपने डेटा के साथ काम करने के तरीके में अधिक लचीलापन रखते हैं।
## रिश्तों की अवधारणा
आइए अपने डेटा पर वापस लौटें और निर्धारित करें कि हम चीजों को कैसे विभाजित करना चाहते हैं। हम जानते हैं कि हम अपने शहरों के लिए नाम और देश को संग्रहित करना चाहते हैं, इसलिए यह शायद एक टेबल में सबसे अच्छा काम करेगा।
| City | Country |
| -------- | ------------- |
| Tokyo | Japan |
| Atlanta | United States |
| Auckland | New Zealand |
लेकिन इससे पहले कि हम अगली तालिका बनाएं, हमें यह पता लगाना होगा कि प्रत्येक शहर को कैसे संदर्भित किया जाए। हमें किसी पहचानकर्ता, आईडी या (तकनीकी डेटाबेस के संदर्भ में) प्राथमिक कुंजी की आवश्यकता है। प्राथमिक कुंजी एक मान है जिसका उपयोग किसी तालिका में एक विशिष्ट पंक्ति की पहचान करने के लिए किया जाता है। हालांकि यह स्वयं एक मूल्य पर आधारित हो सकता है (उदाहरण के लिए, हम शहर के नाम का उपयोग कर सकते हैं), यह लगभग हमेशा एक संख्या या अन्य पहचानकर्ता होना चाहिए। हम नहीं चाहते कि आईडी कभी बदले क्योंकि इससे रिश्ता टूट जाएगा। आप ज्यादातर मामलों में पाएंगे कि प्राथमिक कुंजी या आईडी एक स्वतः उत्पन्न संख्या होगी।
> प्राथमिक कुंजी को अक्सर पीके के रूप में संक्षिप्त किया जाता है
### शहरों
| city_id | City | Country |
| ------- | -------- | ------------- |
| 1 | Tokyo | Japan |
| 2 | Atlanta | United States |
| 3 | Auckland | New Zealand |
> ✅ आप देखेंगे कि हम इस पाठ के दौरान "आईडी" और "प्राथमिक कुंजी" शब्दों का परस्पर उपयोग करते हैं। यहाँ की अवधारणाएँ DataFrames पर लागू होती हैं, जिन्हें आप बाद में एक्सप्लोर करेंगे। डेटाफ़्रेम "प्राथमिक कुंजी" की शब्दावली का उपयोग नहीं करते हैं, हालांकि आप देखेंगे कि वे उसी तरह से बहुत अधिक व्यवहार करते हैं।
हमारे शहरों की तालिका बनाने के साथ, आइए वर्षा को संग्रहित करें। हम शहर के बारे में पूरी जानकारी की नकल करने के बजाय आईडी का उपयोग कर सकते हैं। हमें यह भी सुनिश्चित करना चाहिए कि नई बनाई गई तालिका में एक *id* कॉलम भी हो, क्योंकि सभी तालिकाओं में एक आईडी या प्राथमिक कुंजी होनी चाहिए।
### बारिश
| rainfall_id | city_id | Year | Amount |
| ----------- | ------- | ---- | ------ |
| 1 | 1 | 2018 | 1445 |
| 2 | 1 | 2019 | 1874 |
| 3 | 1 | 2020 | 1690 |
| 4 | 2 | 2018 | 1779 |
| 5 | 2 | 2019 | 1111 |
| 6 | 2 | 2020 | 1683 |
| 7 | 3 | 2018 | 1386 |
| 8 | 3 | 2019 | 942 |
| 9 | 3 | 2020 | 1176 |
नव निर्मित **वर्षा** तालिका के अंदर **city_id** कॉलम पर ध्यान दें। इस कॉलम में वे मान हैं जो **शहरों** तालिका में आईडी का संदर्भ देते हैं। तकनीकी संबंधपरक डेटा के संदर्भ में, इसे **विदेशी कुंजी** कहा जाता है; यह किसी अन्य तालिका से प्राथमिक कुंजी है। आप इसे केवल एक संदर्भ या सूचक के रूप में सोच सकते हैं। **सिटी_आईडी** 1 संदर्भ टोक्यो।
> [!नोट] विदेशी कुंजी को अक्सर FK . के रूप में संक्षिप्त किया जाता है
## डेटा पुनर्प्राप्त करना
हमारे डेटा को दो तालिकाओं में विभाजित करके, आप सोच रहे होंगे कि हम इसे कैसे पुनः प्राप्त करते हैं। यदि हम एक रिलेशनल डेटाबेस जैसे MySQL, SQL सर्वर या Oracle का उपयोग कर रहे हैं, तो हम स्ट्रक्चर्ड क्वेरी लैंग्वेज या SQL नामक भाषा का उपयोग कर सकते हैं। SQL (कभी-कभी उच्चारित अगली कड़ी) एक मानक भाषा है जिसका उपयोग रिलेशनल डेटाबेस में डेटा को पुनः प्राप्त करने और संशोधित करने के लिए किया जाता है।
डेटा पुनर्प्राप्त करने के लिए आप `SELECT` कमांड का उपयोग करते हैं। इसके मूल में, आप उन स्तंभों को **चुनते हैं जिन्हें आप देखना चाहते हैं **से** उस तालिका में जिसमें वे शामिल हैं। यदि आप केवल शहरों के नाम प्रदर्शित करना चाहते हैं, तो आप निम्न का उपयोग कर सकते हैं:
```sql
SELECT city
FROM cities;
-- Output:
-- Tokyo
-- Atlanta
-- Auckland
```
`चयन` वह जगह है जहां आप कॉलम सूचीबद्ध करते हैं, और `से` वह जगह है जहां आप टेबल सूचीबद्ध करते हैं।
> [नोट] SQL सिंटैक्स केस-असंवेदनशील है, जिसका अर्थ है `चुनें` और `चयन` का मतलब एक ही है। हालाँकि, आप जिस प्रकार के डेटाबेस का उपयोग कर रहे हैं उसके आधार पर कॉलम और टेबल केस संवेदनशील हो सकते हैं। नतीजतन, प्रोग्रामिंग में हर चीज को हमेशा केस संवेदी की तरह व्यवहार करना सबसे अच्छा अभ्यास है। SQL क्वेरी लिखते समय सामान्य परंपरा यह है कि कीवर्ड को सभी अपर-केस अक्षरों में रखा जाए।
उपरोक्त क्वेरी सभी शहरों को प्रदर्शित करेगी। आइए कल्पना करें कि हम केवल न्यूजीलैंड में शहरों को प्रदर्शित करना चाहते थे। हमें किसी प्रकार के फ़िल्टर की आवश्यकता है। इसके लिए SQL कीवर्ड `WHERE` या "जहां कुछ सच है" है।
```sql
SELECT city
FROM cities
WHERE country = 'New Zealand';
-- Output:
-- Auckland
```
## डेटा में शामिल होना
अब तक हमने एक ही टेबल से डेटा रिकवर किया है। अब हम **शहरों** और **वर्षा** दोनों के डेटा को एक साथ लाना चाहते हैं। यह उन्हें एक साथ *शामिल करके* किया जाता है। आप प्रभावी रूप से दो तालिकाओं के बीच एक सीम बनाएंगे, और प्रत्येक तालिका से एक कॉलम के मानों का मिलान करेंगे।
हमारे उदाहरण में, हम **वर्षा** में **शहर_आईडी** कॉलम का मिलान **शहरों** में **शहर_आईडी** कॉलम से करेंगे। यह अपने संबंधित शहर के साथ वर्षा मूल्य से मेल खाएगा। हम जिस प्रकार के जॉइन करेंगे, उसे *इनर* जॉइन कहा जाता है, जिसका अर्थ है कि यदि कोई पंक्तियाँ दूसरी टेबल की किसी भी चीज़ से मेल नहीं खाती हैं तो वे प्रदर्शित नहीं होंगी। हमारे मामले में हर शहर में बारिश होती है, इसलिए सब कुछ प्रदर्शित किया जाएगा।
आइए हमारे सभी शहरों के लिए 2019 की वर्षा को पुनः प्राप्त करें।
हम इसे चरणों में करने जा रहे हैं। पहला कदम सीम के लिए कॉलम को इंगित करके डेटा को एक साथ जोड़ना है - **city_id** जैसा कि पहले हाइलाइट किया गया था।
```sql
SELECT cities.city
rainfall.amount
FROM cities
INNER JOIN rainfall ON cities.city_id = rainfall.city_id
```
हमने उन दो कॉलमों को हाइलाइट किया है जो हम चाहते हैं, और तथ्य यह है कि हम टेबल्स को **city_id** द्वारा एक साथ जोड़ना चाहते हैं। अब हम केवल वर्ष 2019 को फ़िल्टर करने के लिए `WHERE` स्टेटमेंट जोड़ सकते हैं।
```sql
SELECT cities.city
rainfall.amount
FROM cities
INNER JOIN rainfall ON cities.city_id = rainfall.city_id
WHERE rainfall.year = 2019
-- Output
-- city | amount
-- -------- | ------
-- Tokyo | 1874
-- Atlanta | 1111
-- Auckland | 942
```
## सारांश
रिलेशनल डेटाबेस कई तालिकाओं के बीच सूचनाओं को विभाजित करने के आसपास केंद्रित होते हैं जिन्हें बाद में प्रदर्शन और विश्लेषण के लिए एक साथ लाया जाता है। यह गणना करने और अन्यथा डेटा में हेरफेर करने के लिए उच्च स्तर की लचीलापन प्रदान करता है। आपने रिलेशनल डेटाबेस की मूल अवधारणाओं को देखा है, और दो तालिकाओं के बीच जुड़ने का तरीका देखा है।
## चुनौती
इंटरनेट पर कई रिलेशनल डेटाबेस उपलब्ध हैं। आप ऊपर सीखे गए कौशल का उपयोग करके डेटा का पता लगा सकते हैं।
आपके लिए SQL और रिलेशनल डेटाबेस अवधारणाओं की खोज जारी रखने के लिए [Microsoft Learn](https://docs.microsoft.com/learn?WT.mc_id=academic-40229-cxa) पर कई संसाधन उपलब्ध हैं
- [संबंधपरक डेटा की अवधारणाओं का वर्णन करें](https://docs.microsoft.com//learn/modules/describe-concepts-of-relational-data?WT.mc_id=academic-40229-cxa)
- [Transact-SQL के साथ क्वेरी करना प्रारंभ करें](https://docs.microsoft.com//learn/paths/get-started-querying-with-transact-sql?WT.mc_id=academic-40229-cxa) (ट्रांजैक्ट-एसक्यूएल एसक्यूएल का एक संस्करण है)
- [Microsoft पर SQL सामग्री जानें](https://docs.microsoft.com/learn/browse/?products=azure-sql-database%2Csql-server&expanded=azure&WT.mc_id=academic-40229-cxa)
