MongoDB ट्यूटोरियल: MongoDB डेटाबेस सेट अप करें और क्वेरी चलाएँ

MongoDB से संबंधित मुख्य अवधारणाएँ

अब तक मैंने बार-बार document डेटाबेस कहा है, लेकिन वे वास्तव में हैं क्या? मुख्य अवधारणाएँ इस प्रकार हैं:

• Documents: डेटा को documents नामक ऑब्जेक्ट्स में संग्रहीत किया जाता है। सरल शब्दों में, दस्तावेज़ JSON key-value ऑब्जेक्ट्स जैसे होते हैं। एकल दस्तावेज़ तालिका की एक पंक्ति के बराबर होता है। यदि आप Python प्रोग्रामर हैं, तो एक दस्तावेज़ को डिक्शनरी समझिए—और आप सही होंगे। बस याद रखें कि दस्तावेज़ों में nested दस्तावेज़ हो सकते हैं, जो document डेटाबेस की प्रमुख विशेषताओं में से एक है।
• Collections: कलेक्शन रिलेशनल डेटाबेस की तालिकाओं जैसे होते हैं, लेकिन पंक्तियों के बजाय ये—आपने सही सोचा—दस्तावेज़ रखते हैं। कलेक्शन विशाल डेटा संरचनाएँ हैं, जिनमें हज़ारों या लाखों डिक्शनरी हो सकती हैं।
• Schema-less: यहीं बात दिलचस्प हो जाती है। एक कलेक्शन में अलग-अलग आकार के दस्तावेज़ हो सकते हैं। उदाहरण के लिए, दस्तावेज़ 1 में 10 key-value जोड़े हो सकते हैं जबकि दस्तावेज़ 2 में 15 (बशर्ते जानकारी एक ही श्रेणी/विषय—जैसे उत्पाद—के बारे में हो ताकि कलेक्शन का अर्थ बने)।

यहाँ एक बढ़िया तालिका है जो रिलेशनल और document डेटाबेस के बीच के अंतर का सार प्रस्तुत करती है:

चलिए, अब MongoDB में दस्तावेज़ों के साथ काम करना शुरू करते हैं!

MongoDB सेटअप: डेटा स्रोतों से कनेक्ट करना

Document डेटाबेस पर क्वेरी चलाने के लिए, हमें MongoDB सर्वर इंस्टॉल करना होगा। प्लेटफ़ॉर्म-विशिष्ट निर्देश नीचे हैं:

• Windows के लिए, इस लिंक में दिए निर्देशों का पालन करें।
• Unix-जैसी प्रणालियों के लिए, आप टर्मिनल से MongoDB इंस्टॉल कर सकते हैं:

$ sudo apt-get install -y mongodb

इसके बाद, एक वर्चुअल एनवायरनमेंट के भीतर, pymongo और requests लाइब्रेरी इंस्टॉल करें। pymongo MongoDB सर्वर के लिए आधिकारिक Python एडेप्टर है। हमें API से डेटा खींचने के लिए requests लाइब्रेरी की भी आवश्यकता होगी।

$ pip install pymongo
$ pip install requests

इसके बाद, टर्मिनल से निम्न कमांड द्वारा MongoDB सर्विस शुरू करें:

$ sudo service mongodb start

अब, हम document डेटाबेस में कुछ डेटा लोड करने के लिए तैयार हैं। ऐसा करते समय दो परिदृश्य होते हैं:

1. आपके पास डेटा स्थानीय रूप से उपयुक्त फ़ॉर्मैट (JSON, BSON, YAML, या XML) में है।
2. आपको बाहरी स्रोतों (आमतौर पर APIs) से डेटा खींचना है।

हम दोनों को कवर करेंगे। पहले, drone_races.json नामक कलेक्शन को लोकल से लोड करते हैं। यह स्निपेट देखें:

import json

from pymongo import MongoClient

# Establish connection to MongoDB
client = MongoClient("localhost", 27017)
# Create a database named "drones"
drones = client["drones"]
# Create a collection named "races"
races = drones["races"]

# Load dataset into MongoDB
with open("data/drone_races.json", "r") as file:
   data = json.load(file)
   races.insert_many(data)

हमारे लिए दो सबसे महत्वपूर्ण ऑब्जेक्ट हैं drones (एक डेटाबेस) और races (एक कलेक्शन)। अधिकांश फ़ंक्शन और मेथड कलेक्शन से संबंधित होंगे। डेटाबेस ऑब्जेक्ट मुख्यतः कलेक्शन प्रबंधन के लिए उपयोग होते हैं।

अब, वही डेटा API के माध्यम से कैसे लोड करें, देखते हैं। मैंने Mockaroo नामक सेवा से एक API के रूप में जानकारी संग्रहीत की है। यह स्निपेट देखें:

import requests
from pymongo import MongoClient

# Fetch data from the API
api_url = (
   "https://my.api.mockaroo.com/drone_race_matches.json?key=6f5a6b50"
)
response = requests.get(api_url)

if response.status_code == 200:
   data = response.json()  # Get the JSON data from the API

   # Establish a connection to MongoDB
   client = MongoClient()

   # Access or create a specific database
   drones = client["drones"]

   # Access or create a specific collection within the database
   races = drones["races"]

   # Insert the fetched data into the MongoDB collection
   races.insert_many(data)
else:
   print("Failed to fetch data from the API.")

हमने drones document डेटाबेस के races कलेक्शन में कुछ डेटा लोड किया है—या किया है? आइए क्वेरी चलाकर जाँचते हैं!

प्राथमिक MongoDB क्वेरी

MongoDB में दस्तावेज़ों की गिनती

किसी कलेक्शन में डेटा है या नहीं, यह जानने के लिए हमें अंदर के दस्तावेज़ों की गिनती करनी होगी। इसके लिए हम count_documents मेथड का उपयोग करेंगे:

>>> races.count_documents({})
9040

count_documents को पास की गई खाली डिक्शनरी पर ध्यान दें। MongoDB में उस डिक्शनरी को फ़िल्टर कहा जाता है। ट्यूटोरियल में आगे बढ़ते हुए, हम सीखेंगे कि अलग-अलग प्रकार के फ़िल्टर बनाने के लिए इस डिक्शनरी को कैसे भरें। अभी, हमारे पास कोई फ़िल्टर नहीं है। उपरोक्त कोड SQL में SELECT COUNT(*) FROM table_name के समान है।

हमें 9040 दस्तावेज़ मिले—वाह! अब, कुछ डेटा देखते हैं।

MongoDB में एक दस्तावेज़ निकालना

pymongo से एक दस्तावेज़ देखने के लिए हम find_one मेथड का उपयोग कर सकते हैं:

from pprint import pprint

>>> pprint(races.find_one())
{'_id': ObjectId('659d31e9255ec0cf4bab529d'),
'laps': 3,
'league': 'F1 Drones',
'location': {'city': 'Ford',
             'country': 'United Kingdom',
             'date': 'error: invalid date "2024-10-25"',
             'venue': 'Manhattan Seas'},
'name': 'Honorable',
'pilots': {'drone': 'DJI3-old',
           'finishing_position': 66,
           'name': 'Kariotta Cow',
           'qualification_time': 27.39,
           'team': 'Sky Crusaders',
           'telemetry': {'altitude': 34.3,
                         'battery_voltage': 12.1,
                         'speed': 68.3,
                         'timestamp': 'error: invalid date '
                                      '"2024-10-25T14:09:26Z"'}},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat'],
'weather_conditions': 'snowy'}

इस दस्तावेज़ के फ़ील्ड (keys) पर ध्यान दें। यह एक एकल ड्रोन रेस की जानकारी संग्रहीत करता है और निम्न जैसी सूचनाएँ शामिल हैं:

• लैप्स की संख्या
• मैच के समय मौसम की स्थिति
• मैच के दौरान पायलट (सभी नहीं)
• मैच के प्रायोजक, इत्यादि

दस्तावेज़ में एक आवश्यक _id फ़ील्ड भी होता है, जो एक अद्वितीय हैश है।

MongoDB में सभी दस्तावेज़ चुनना

count_documents हमेशा एक संख्या देता है, लेकिन कई बार हम वह डेटा देखना चाहते हैं जो हमारी क्वेरी से मेल खाता है। इसके लिए, हम find_one के बड़े भाई find का उपयोग कर सकते हैं:

from pprint import pprint

for race in races.find():
   pprint(race)
   break

{'_id': ObjectId('659d31e9255ec0cf4bab529d'),
'laps': 3,
'league': 'F1 Drones',
'location': {'city': 'Ford',
             'country': 'United Kingdom',
             'date': 'error: invalid date "2024-10-25"',
             'venue': 'Manhattan Seas'},
'name': 'Honorable',
'pilots': {'drone': 'DJI3-old',
           'finishing_position': 66,
           'name': 'Kariotta Cow',
           'qualification_time': 27.39,
           'team': 'Sky Crusaders',
           'telemetry': {'altitude': 34.3,
                         'battery_voltage': 12.1,
                         'speed': 68.3,
                         'timestamp': 'error: invalid date '
                                      '"2024-10-25T14:09:26Z"'}},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat'],
'weather_conditions': 'snowy'}

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

MongoDB में शर्त के आधार पर चयन

सबसे सरल फ़िल्टर से शुरू करते हैं—वे दस्तावेज़ चुनना जहाँ कोई फ़ील्ड किसी मान के बराबर हो। यह इस SQL के समान है:

SELECT *
 FROM table_name
WHERE field = value

इसे MongoDB में करते हैं:

criteria = {"sponsors": "Fat Shark"}

fat_shark_races = races.count_documents(criteria)
fat_shark_races

6194

ऊपर, हम उन रेसों का चयन कर रहे हैं जिनके प्रायोजक "Fat Shark" हैं। सिंटैक्स बस एक डिक्शनरी है जो sponsors फ़ील्ड को "Fat Shark" से मैप करती है।

यदि MongoDB क्वेरी भाषा में सामान्य असमानता ऑपरेटर न हों तो वह भाषा ही क्या! यहाँ “less than” ऑपरेटर का उपयोग ऐसे करें:

criteria = {"pilots.qualification_time": {"$lt": 10}}

quick_races = races.count_documents(criteria)
quick_races

3061

उपरोक्त क्वेरी MQL की चार नई विशेषताएँ दिखाती है:

• डॉट नोटेशन से उप-फ़ील्ड तक पहुँचा जा सकता है। pilots.qualification_time पायलट्स के भीतर नेस्टेड क्वालिफिकेशन टाइम निकालता है।
• MQL में लगभग सभी ऑपरेटर डॉलर साइन से शुरू होते हैं।
• ऑपरेटर ऊपर की तरह nested दस्तावेज़ में प्रयुक्त होते हैं।
• $lt “less than” ऑपरेटर है।

तो, इस क्वेरी का परिणाम बताता है कि 3061 मैच ऐसे थे जहाँ किसी एक पायलट का क्वालिफिकेशन टाइम 10 सेकंड से कम था। यह क्वेरी $lt ऑपरेटर से संभव हुई। इसके “भाई-बहन” ये हैं:

• $lte: less than or equal
• $gt: greater than
• $gte: greater than or equal

इनकी सिंटैक्स $lt जैसी ही है।

MongoDB में लॉजिकल कंडीशनल ऑपरेटर के साथ चयन

MQL में $and और $or जैसे लॉजिकल कंडीशनल ऑपरेटर भी होते हैं। पहले $or से शुरू करते हैं।

हम वे रेस प्राप्त करेंगे जिनका स्थान United Kingdom है या जिनके प्रायोजक Etisalat हैं:

criteria = {
   "$or": [
       {"location.country": "United Kingdom"},
       {"sponsors": "Etisalat"},
   ]
}

>>> races.count_documents(criteria)

6223

फिर से, विस्तृत व्याख्या के लिए Explain code बटन का उपयोग करें।

हमारे मानदंडों से मेल खाते 6223 दस्तावेज़ हैं। एक ही फ़ील्ड के लिए अनेक मानों पर OR लॉजिक लागू करने हेतु हम $in ऑपरेटर का उपयोग कर सकते हैं।

उदाहरण के लिए, खराब मौसम की स्थितियों की जाँच इस तरह कर सकते हैं:

criteria = {
   "weather_conditions": {"$in": ["rainy", "snowy", "cloudy"]}
}

>>> races.count_documents(criteria)

5508

यह क्वेरी $or के साथ लिखना कठिन होता। अब, $and पर आते हैं।

इस बार, हम वे रेस ढूँढना चाहते हैं जिनका स्थान Australia है और प्रायोजक Fat Shark। $and के साथ ऐसे करें:

criteria = {
   "$and": [
       {"location.country": "Australia"},
       {"sponsors": "Fat Shark"},
   ]
}
>>> races.count_documents(criteria)
193

लेकिन व्यवहार में, आप शायद ही $and का इस्तेमाल करेंगे, क्योंकि इसे अधिक सरल तरीके से लिखा जा सकता है:

criteria = {
   "location.country": "Australia",
   "sponsors": "Fat Shark",
}

races.count_documents(criteria)
193

AND लॉजिकल ऑपरेटर प्राप्त करने के लिए फ़िल्टर डिक्शनरी में और key-value जोड़ दें।

अंत में, $nin ऑपरेटर है, जो non-membership जाँचता है। उदाहरण के लिए, हम वे सभी मैच लौटा सकते हैं जो United States, United Kingdom या Australia में नहीं हुए:

criteria = {
   "location.country": {
       "$nin": ["United States", "United Kingdom", "Australia"]
   }
}

>>> races.count_documents(criteria)
126

इससे केवल United Arab Emirates देश बचता है, तो उपरोक्त क्वेरी वास्तव में ऐसे भी लिखी जा सकती है:

criteria = {"location.country": "United Arab Emirates"}

>>> races.count_documents(criteria)
126

पर बात समझ में आ गई होगी।

MongoDB में null या अनुपस्थित मानों पर क्वेरी

Null या अनुपस्थित मानों की जाँच सभी डेटा विश्लेषण कार्यों में सामान्य प्रक्रिया है। इसलिए, MongoDB में इसके लिए एक ऑपरेटर है—$exists। नीचे दो उदाहरण हैं जो जाँचते हैं कि कोई फ़ील्ड मौजूद है या नहीं:

criteria = {"location.district": {"$exists": True}}

>>> races.count_documents(criteria)

0

हम्म, लगता है district फ़ील्ड मौजूद नहीं है। laps फ़ील्ड तो हर दस्तावेज़ में होना चाहिए क्योंकि यह रेस के बारे में मुख्य जानकारी है।

criteria = {"laps": {"$exists": True}}

races.count_documents(criteria)
9040

अपेक्षित रूप से, सभी दस्तावेज़ों में laps फ़ील्ड है। लेकिन वे फ़ील्ड जो मौजूद हैं पर उनका मान null है, उनका क्या? हम यह भी जाँच सकते हैं:

criteria = {"pilots.finishing_position": None}

races.count_documents(criteria)
0

Python के बिल्ट-इन None ऑब्जेक्ट का उपयोग करके, हम किसी भी फ़ील्ड के मान की अनुपस्थिति जाँच सकते हैं।

कुछ उन्नत परिदृश्य भी होते हैं जिनमें null या अस्तित्व जाँच की आवश्यकता पड़ती है। उदाहरण के लिए, आप किसी विशाल nested array के कुछ तत्त्वों के अस्तित्व की जाँच करना चाह सकते हैं।

इसके लिए, हम MQL में array indexing सिंटैक्स का उपयोग कर सकते हैं। जैसे, केवल एक प्रायोजक वाली रेस ढूँढने के लिए हमें sponsors array के दूसरे तत्त्व के अस्तित्व की जाँच करनी होगी:

# Counting starts with 0 as always
criteria = {"sponsors.1": {"$exists": False}}

races.count_documents(criteria)
2929

और यह उतना ही आसान है जितना कि key में इंडेक्स संख्या जोड़ना। तो, हमारे कलेक्शन में लगभग 3000 रेस केवल एक इकाई द्वारा प्रायोजित थीं।

यह array indexing सिंटैक्स केवल $exists के लिए ही नहीं, कई अन्य ऑपरेटरों के साथ भी काम करता है।

प्रोजेक्शन (फ़ील्ड सीमित करना)

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

तो, केवल इच्छित फ़ील्ड लौटाने के लिए हम प्रोजेक्शन का उपयोग कर सकते हैं। ऐसे करें:

criteria = {"pilots.telemetry.speed": {"$gte": 20}}
projection = {
   "sponsors": 1,
   "location.country": 1,
   "pilots.telemetry.speed": 1,
   "pilots.name": 1,
}

fast_pilots = races.find(criteria, projection)

for pilot in fast_pilots:
   pprint(pilot)
   break

ऊपर के मामले में, हम सामान्य रूप से फ़िल्टर मानदंड लिख रहे हैं, लेकिन इस बार हम चार फ़ील्ड 1 पर सेट करके एक और दस्तावेज़ परिभाषित कर रहे हैं। यदि हम इस projection दस्तावेज़ को find या count_documents के दूसरे आर्गुमेंट के रूप में पास करते हैं, तो आउटपुट में हमें केवल वही फ़ील्ड मिलेंगे जो 1 पर सेट हैं।

{'_id': ObjectId('659d31e9255ec0cf4bab529d'),
'location': {'country': 'United Kingdom'},
'pilots': {'name': 'Kariotta Cow', 'telemetry': {'speed': 68.3}},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat']}

भले ही हमने केवल चार फ़ील्ड चुने, शरारती _id फ़ील्ड भी आ गया। इस व्यवहार को दबाने के लिए, उसे projection डिक्शनरी में 0 पर सेट करें:

criteria = {"pilots.telemetry.speed": {"$gte": 20}}
projection = {
   "sponsors": 1,
   "location.country": 1,
   "pilots.telemetry.speed": 1,
   "pilots.name": 1,
   "_id": 0,
}

fast_pilots = races.find(criteria, projection)

for pilot in fast_pilots:
   pprint(pilot)
   break

{'location': {'country': 'United Kingdom'},
'pilots': {'name': 'Kariotta Cow', 'telemetry': {'speed': 68.3}},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat']}

अब दृश्य और साफ़-सुथरा है।

अंत में, कुछ फ़ील्ड छोड़कर बाक़ी सभी लौटाने हेतु, उन फ़ील्ड को 0 पर सेट करें:

projection = {"_id": 0, "league": 0, "pilots": 0}

# Empty criteria for this one
races.find_one({}, projection)

{'name': 'Honorable',
'location': {'venue': 'Manhattan Seas',
 'city': 'Ford',
 'country': 'United Kingdom',
 'date': 'error: invalid date "2024-10-25"'},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat'],
'laps': 3,
'weather_conditions': 'snowy'}

जैसा कि आप देख सकते हैं, इस बार _id, league और pilots को छोड़कर सारे फ़ील्ड लौटे हैं।

निष्कर्ष

यह ट्यूटोरियल डेटाबेस प्रबंधन उपकरण के रूप में MongoDB के विशाल दायरे के साथ पूरा न्याय नहीं करता। आज हमने केवल GET क्वेरियाँ (सूचना प्राप्त करने वाली क्वेरियाँ) कवर कीं, लेकिन MongoDB डेटा विशेषज्ञों को document डेटाबेस में सूचना insert, update या delete करने की भी अनुमति देता है। हमने एक पूरी श्रेणी—aggregations—की क्वेरियाँ भी छोड़ दीं।

ये सभी विषय इस लेख के दायरे से बाहर हैं और इन्हें सीखने के लिए अतिरिक्त संसाधनों की आवश्यकता होती है। क्यों न आप इन्हें देखें:

• Python के साथ डेटा साइंस में MongoDB का परिचय—एक व्यापक कोर्स जो aggregations जैसी उन्नत क्वेरियाँ भी कवर करता है
• Python में MongoDB का परिचय—एक और MongoDB ट्यूटोरियल जो pymongo के साथ CRUD (create, read, update, delete) ऑपरेशंस कवर करता है
• NoSQL अवधारणाएँ—यदि आप NoSQL डेटाबेस में रुचि रखते हैं, तो यह कोर्स आपके लिए है। document डेटाबेस के अलावा, यह अन्य नॉन-रिलेशनल डेटाबेस भी कवर करता है।