पायथन और मोंगोडीबी:नोएसक्यूएल डेटाबेस से जुड़ना

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

इस ट्यूटोरियल में, आप सीखेंगे:

• क्या MongoDB है
• कैसे इंस्टॉल करें और चलाएं मोंगोडीबी
• MongoDB डेटाबेस के साथ कैसे कार्य करें
• निम्न-स्तरीय PyMongo ड्राइवर का उपयोग कैसे करें MongoDB के साथ इंटरफेस करने के लिए
• उच्च-स्तरीय MongoEngine ऑब्जेक्ट-डॉक्यूमेंट मैपर (ODM) का उपयोग कैसे करें

इस पूरे ट्यूटोरियल में, आप कुछ उदाहरण लिखेंगे जो MongoDB के लचीलेपन और शक्ति और इसके महान पायथन समर्थन को प्रदर्शित करेंगे। उन उदाहरणों के लिए स्रोत कोड डाउनलोड करने के लिए, नीचे दिए गए लिंक पर क्लिक करें:

स्रोत कोड प्राप्त करें: इस ट्यूटोरियल में पायथन के साथ MongoDB का उपयोग करने के बारे में जानने के लिए आप जिस स्रोत कोड का उपयोग करेंगे, उसे प्राप्त करने के लिए यहां क्लिक करें।

SQL बनाम NoSQL डेटाबेस का उपयोग करना

दशकों से, SQL डेटाबेस बड़े और स्केलेबल डेटाबेस सिस्टम बनाने के इच्छुक डेवलपर्स के लिए एकमात्र विकल्पों में से एक थे। हालांकि, जटिल डेटा संरचनाओं को संग्रहीत करने की बढ़ती आवश्यकता के कारण NoSQL . का जन्म हुआ डेटाबेस। यह नए प्रकार का डेटाबेस सिस्टम डेवलपर्स को विषम और संरचना रहित डेटा को कुशलतापूर्वक संग्रहीत करने की अनुमति देता है।

सामान्य तौर पर, NoSQL डेटाबेस सिस्टम SQL रिलेशनल डेटाबेस मैनेजमेंट सिस्टम (RDBMS) से बहुत अलग तरीके से डेटा को स्टोर और पुनर्प्राप्त करते हैं।

जब वर्तमान में उपलब्ध डेटाबेस तकनीकों में से चुनने की बात आती है, तो आपको SQL या NoSQL सिस्टम का उपयोग करने के बीच निर्णय लेने की आवश्यकता हो सकती है। उन दोनों में विशिष्ट विशेषताएं हैं जिन्हें आपको एक या दूसरे को चुनते समय विचार करना चाहिए। यहां उनके कुछ अधिक महत्वपूर्ण अंतर दिए गए हैं:

दो प्रकार के डेटाबेस के बीच कई अन्य अंतर हैं, लेकिन ऊपर वर्णित कुछ अधिक महत्वपूर्ण हैं जिनके बारे में जानना आवश्यक है।

डेटाबेस चुनते समय, आपको इसकी खूबियों और कमजोरियों पर ध्यान से विचार करना चाहिए। आपको यह भी विचार करने की आवश्यकता है कि डेटाबेस आपके विशिष्ट परिदृश्य और आपके एप्लिकेशन की आवश्यकताओं में कैसे फिट बैठता है। कभी-कभी एक व्यापक प्रणाली के विभिन्न पहलुओं को संभालने के लिए SQL और NoSQL डेटाबेस के संयोजन का उपयोग करना सही समाधान होता है।

SQL डेटाबेस के कुछ सामान्य उदाहरणों में शामिल हैं:

• SQLite
• MySQL
• ओरेकल
• पोस्टग्रेएसक्यूएल
• माइक्रोसॉफ्ट एसक्यूएल सर्वर

NoSQL डेटाबेस उदाहरणों में शामिल हैं:

• डायनेमोडीबी
• कैसंड्रा
• रेडिस
• काउचडीबी
• रीथिंकडीबी
• रेवेनडीबी
• मोंगोडीबी

हाल के वर्षों में, SQL और NoSQL डेटाबेस ने भी विलय करना शुरू कर दिया है। उदाहरण के लिए, डेटाबेस सिस्टम, जैसे PostgreSQL, MySQL और Microsoft SQL सर्वर अब JSON डेटा को संग्रहीत करने और क्वेरी करने का समर्थन करते हैं, जैसे NoSQL डेटाबेस। इसके साथ, अब आप दोनों तकनीकों के साथ समान परिणाम प्राप्त कर सकते हैं। लेकिन आपको अभी भी कई NoSQL सुविधाएँ नहीं मिलती हैं, जैसे क्षैतिज स्केलिंग और उपयोगकर्ता के अनुकूल इंटरफ़ेस।

SQL और NoSQL डेटाबेस पर इस संक्षिप्त पृष्ठभूमि के साथ, आप इस ट्यूटोरियल के मुख्य विषय पर ध्यान केंद्रित कर सकते हैं:MongoDB डेटाबेस और इसे पायथन में कैसे उपयोग करें।

MongoDB के साथ NoSQL डेटाबेस प्रबंधित करना

MongoDB एक दस्तावेज़-उन्मुख है डेटाबेस को NoSQL के रूप में वर्गीकृत किया गया है। यह हाल के वर्षों में पूरे उद्योग में लोकप्रिय हो गया है और पायथन के साथ बहुत अच्छी तरह से एकीकृत है। पारंपरिक SQL RDBMS के विपरीत, MongoDB संग्रह . का उपयोग करता है दस्तावेजों . के टेबल . के बजाय पंक्तियों . में से डेटा व्यवस्थित और संग्रहीत करने के लिए।

MongoDB स्कीमा रहित और लचीले JSON जैसे दस्तावेज़ों में डेटा संग्रहीत करता है। यहां, स्कीमलेस इसका मतलब है कि एक कठोर तालिका स्कीमा को संतुष्ट करने की आवश्यकता के बिना, आपके पास एक ही संग्रह में फ़ील्ड के विभिन्न सेट वाले दस्तावेज़ हो सकते हैं ।

आप समय के साथ अपने दस्तावेज़ों और डेटा की संरचना को बदल सकते हैं, जिसके परिणामस्वरूप एक लचीली प्रणाली बन जाती है जो आपको डेटा माइग्रेशन की जटिल प्रक्रिया की आवश्यकता के बिना आवश्यकता परिवर्तनों के लिए त्वरित रूप से अनुकूलित करने की अनुमति देती है। हालाँकि, नए दस्तावेज़ों की संरचना को बदलने में व्यापार-बंद यह है कि बाहर निकलने वाले दस्तावेज़ अद्यतन स्कीमा के साथ असंगत हो जाते हैं। तो यह एक ऐसा विषय है जिसे सावधानी से प्रबंधित करने की आवश्यकता है।

नोट: JSON का अर्थ है जावास्क्रिप्ट ऑब्जेक्ट नोटेशन . यह एक फ़ाइल स्वरूप है जिसमें मानव-पठनीय संरचना होती है जिसमें कुंजी-मूल्य जोड़े होते हैं जिन्हें मनमाने ढंग से गहरा किया जा सकता है।

MongoDB C++ में लिखा गया है और MongoDB Inc. द्वारा सक्रिय रूप से विकसित किया गया है। यह macOS, Windows, Solaris, और अधिकांश Linux वितरण जैसे सभी प्रमुख प्लेटफार्मों पर चलता है। सामान्य तौर पर, MongoDB डेटाबेस के पीछे तीन मुख्य विकास लक्ष्य होते हैं:

1. अच्छी तरह से स्केल करें
2. रिच डेटा स्ट्रक्चर स्टोर करें
3. एक परिष्कृत क्वेरी तंत्र प्रदान करें

MongoDB एक वितरित . है डेटाबेस, इसलिए उच्च उपलब्धता, क्षैतिज स्केलिंग, और भौगोलिक वितरण सिस्टम में निर्मित होते हैं। यह लचीले JSON जैसे दस्तावेज़ों में डेटा संग्रहीत करता है। आप इन दस्तावेज़ों को अपने अनुप्रयोगों में वस्तुओं को मैप करने के लिए मॉडल कर सकते हैं, जिससे आपके डेटा के साथ प्रभावी ढंग से काम करना संभव हो जाता है।

MongoDB एक शक्तिशाली क्वेरी भाषा प्रदान करता है जो तदर्थ प्रश्नों, अनुक्रमण, एकत्रीकरण, भू-स्थानिक खोज, पाठ खोज और बहुत कुछ का समर्थन करता है। यह आपको अपने डेटा तक पहुंचने और काम करने के लिए एक शक्तिशाली टूल किट के साथ प्रस्तुत करता है। अंत में, MongoDB स्वतंत्र रूप से उपलब्ध है और इसमें महान पायथन समर्थन है।

MongoDB की विशेषताओं की समीक्षा करना

अब तक, आपने सीखा कि MongoDB क्या है और इसके मुख्य लक्ष्य क्या हैं। इस खंड में, आप MongoDB की कुछ अधिक महत्वपूर्ण विशेषताओं के बारे में जानेंगे। जहाँ तक डेटाबेस प्रबंधन पक्ष की बात है, MongoDB निम्नलिखित सुविधाएँ प्रदान करता है:

• क्वेरी समर्थन: आप कई मानक क्वेरी प्रकारों का उपयोग कर सकते हैं, जैसे मिलान (== ), तुलना (< , > ), और रेगुलर एक्सप्रेशन.
• डेटा आवास: आप वस्तुतः किसी भी प्रकार का डेटा संग्रहीत कर सकते हैं, चाहे वह संरचित हो, आंशिक रूप से संरचित हो, या बहुरूपी भी हो।
• मापनीयता: यह सर्वर क्लस्टर में और मशीनों को जोड़कर और अधिक प्रश्नों को संभालता है।
• लचीलापन और चपलता: आप इसके साथ जल्दी से एप्लिकेशन विकसित कर सकते हैं।
• दस्तावेज़ अभिविन्यास और योजनाहीनता: आप एक ही दस्तावेज़ में डेटा मॉडल के संबंध में सभी जानकारी संग्रहीत कर सकते हैं।
• समायोज्य स्कीमा: आप डेटाबेस के स्कीमा को तुरंत बदल सकते हैं, जिससे नई सुविधाएं प्रदान करने या मौजूदा समस्याओं को ठीक करने के लिए आवश्यक समय कम हो जाता है।
• संबंधपरक डेटाबेस कार्यात्मकताएं: आप इंडेक्सिंग जैसे रिलेशनल डेटाबेस के लिए सामान्य क्रियाएं कर सकते हैं।

संचालन पक्ष के लिए, MongoDB कुछ उपकरण और सुविधाएँ प्रदान करता है जो आपको अन्य डेटाबेस सिस्टम में नहीं मिलेंगे:

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

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

MongoDB इंस्टॉल करना और चलाना

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

1. समुदाय संस्करण आपके डेटा तक पहुंचने और विश्लेषण करने के शक्तिशाली तरीके प्रदान करने के लिए तदर्थ प्रश्नों, अनुक्रमण और रीयल-टाइम एकत्रीकरण के साथ लचीला दस्तावेज़ मॉडल प्रदान करता है। यह संस्करण स्वतंत्र रूप से उपलब्ध है।
2. एंटरप्राइज़ संस्करण सामुदायिक संस्करण के समान सुविधाएँ प्रदान करता है, साथ ही सुरक्षा और निगरानी से संबंधित अन्य उन्नत सुविधाएँ प्रदान करता है। यह वाणिज्यिक संस्करण है, लेकिन आप मूल्यांकन और विकास उद्देश्यों के लिए असीमित समय के लिए इसका निःशुल्क उपयोग कर सकते हैं।

यदि आप विंडोज़ पर हैं, तो आप संपूर्ण निर्देशों के लिए इंस्टॉलेशन ट्यूटोरियल को पढ़ सकते हैं। सामान्य तौर पर, आप डाउनलोड पेज पर जा सकते हैं, उपलब्ध डाउनलोड बॉक्स में विंडोज प्लेटफॉर्म का चयन कर सकते हैं, .msi चुनें। इंस्टॉलर जो आपके वर्तमान सिस्टम में फिट बैठता है, और डाउनलोड करें . पर क्लिक करें ।

इंस्टॉलर चलाएँ और इंस्टॉलेशन विज़ार्ड पर ऑन-स्क्रीन निर्देशों का पालन करें। यह पृष्ठ MongoDB को Windows सेवा के रूप में चलाने के तरीके के बारे में भी जानकारी प्रदान करता है।

यदि आप macOS पर हैं, तो आप अपने सिस्टम पर MongoDB स्थापित करने के लिए Homebrew का उपयोग कर सकते हैं। संपूर्ण मार्गदर्शिका प्राप्त करने के लिए स्थापना ट्यूटोरियल देखें। साथ ही, MongoDB को macOS सेवा के रूप में चलाने के लिए निर्देशों का पालन करना सुनिश्चित करें।

यदि आप Linux पर हैं, तो संस्थापन प्रक्रिया आपके विशिष्ट वितरण पर निर्भर करेगी। विभिन्न लिनक्स सिस्टम पर MongoDB कैसे स्थापित करें, इस पर विस्तृत गाइड के लिए, इंस्टॉलेशन ट्यूटोरियल पेज पर जाएं और उस ट्यूटोरियल का चयन करें जो आपके वर्तमान ऑपरेटिंग सिस्टम से मेल खाता हो। सुनिश्चित करें कि आप MongoDB डेमॉन चलाते हैं, mongod , स्थापना के अंत में।

अंत में, आप Docker का उपयोग करके MongoDB भी स्थापित कर सकते हैं। यह आसान है यदि आप अपने सिस्टम को किसी अन्य इंस्टॉलेशन के साथ अव्यवस्थित नहीं करना चाहते हैं। यदि आप इस इंस्टॉलेशन विकल्प को पसंद करते हैं, तो आप आधिकारिक ट्यूटोरियल को पढ़ सकते हैं और इसके निर्देशों का पालन कर सकते हैं। ध्यान दें कि इस मामले में डॉकर का उपयोग करने के पिछले ज्ञान की आवश्यकता होगी।

आपके सिस्टम पर MongoDB डेटाबेस स्थापित और चलने के साथ, आप mongo का उपयोग करके वास्तविक डेटाबेस के साथ काम करना शुरू कर सकते हैं खोल।

mongo के साथ MongoDB डेटाबेस बनाना शैल

यदि आपने इंस्टॉलेशन और रनिंग निर्देशों का पालन किया है, तो आपके पास पहले से ही आपके सिस्टम पर MongoDB चलने का एक उदाहरण होना चाहिए। अब आप अपने खुद के डेटाबेस बनाना और परीक्षण करना शुरू कर सकते हैं। इस अनुभाग में, आप सीखेंगे कि mongo . का उपयोग कैसे करें डेटाबेस पर दस्तावेज़ बनाने, पढ़ने, अपडेट करने और हटाने के लिए खोल।

mongo चलाना शैल

mongo शेल MongoDB के लिए एक इंटरैक्टिव जावास्क्रिप्ट इंटरफ़ेस है। आप इस टूल का उपयोग अपने डेटा को क्वेरी और हेरफेर करने के साथ-साथ प्रशासनिक संचालन करने के लिए कर सकते हैं। चूंकि यह एक जावास्क्रिप्ट इंटरफ़ेस है, इसलिए आप डेटाबेस को क्वेरी करने के लिए परिचित SQL भाषा का उपयोग नहीं करेंगे। इसके बजाय, आप जावास्क्रिप्ट कोड का उपयोग करेंगे।

mongo लॉन्च करने के लिए खोल, अपना टर्मिनल या कमांड लाइन खोलें और निम्न कमांड चलाएँ:

$ mongo

यह आदेश आपको mongo . पर ले जाता है सीप। इस बिंदु पर, आप शायद शेल के संस्करण और सर्वर पते और पोर्ट पर जानकारी के साथ संदेशों का एक समूह देखेंगे। अंत में, आपको शेल प्रॉम्प्ट के साथ प्रस्तुत किया जाएगा (> ) प्रश्न और आदेश दर्ज करने के लिए।

आप डेटाबेस पते को mongo . के तर्क के रूप में पास कर सकते हैं आज्ञा। आप कई विकल्पों का भी उपयोग कर सकते हैं, जैसे दूरस्थ डेटाबेस तक पहुँचने के लिए होस्ट और पोर्ट को निर्दिष्ट करना, और इसी तरह। mongo . का उपयोग करने के तरीके के बारे में अधिक जानकारी के लिए कमांड, आप चला सकते हैं mongo --help ।

कनेक्शन स्थापित करना

जब आप mongo चलाते हैं तर्क के बिना कमांड, यह शेल लॉन्च करता है और mongod द्वारा प्रदान किए गए डिफ़ॉल्ट स्थानीय सर्वर से जुड़ता है mongod://127.0.0.1:27017 . पर प्रक्रिया करें . इसका मतलब है कि आप पोर्ट 27017 . के ज़रिए स्थानीय होस्ट से जुड़े हुए हैं ।

डिफ़ॉल्ट रूप से, mongo शेल test . के साथ एक कनेक्शन स्थापित करके सत्र शुरू करता है डेटाबेस। आप db . के माध्यम से वर्तमान डेटाबेस तक पहुंच सकते हैं वस्तु:

> db
test
>

इस मामले में, db test . का संदर्भ रखता है , जो डिफ़ॉल्ट डेटाबेस है। डेटाबेस स्विच करने के लिए, useआदेश जारी करें , एक तर्क के रूप में एक डेटाबेस नाम प्रदान करना।

उदाहरण के लिए, मान लें कि आप पायथन सामग्री प्रकाशित करने के लिए एक वेबसाइट बनाना चाहते हैं, और आप अपने ट्यूटोरियल और लेखों को संग्रहीत करने के लिए MongoDB का उपयोग करने की योजना बना रहे हैं। उस स्थिति में, आप निम्न आदेश के साथ साइट के डेटाबेस पर स्विच कर सकते हैं:

> use rptutorials
switched to db rptutorials

यह आदेश आपके कनेक्शन को rptutorials . में बदल देता है डेटाबेस। जब तक आप डेटाबेस में वास्तविक डेटा नहीं डालते, तब तक MongoDB फ़ाइल सिस्टम पर भौतिक डेटाबेस फ़ाइल नहीं बनाता है। तो इस मामले में, rptutorials आपकी वर्तमान डेटाबेस सूची में दिखाई नहीं देगा:

> show dbs
admin          0.000GB
config         0.000GB
local          0.000GB
>

mongo शेल बहुत सारी सुविधाएँ और विकल्प प्रदान करता है। यह आपको अपने डेटा को क्वेरी और हेरफेर करने और डेटाबेस सर्वर को स्वयं प्रबंधित करने की अनुमति देता है।

SQL जैसी मानकीकृत क्वेरी भाषा का उपयोग करने के बजाय, mongo शेल जावास्क्रिप्ट प्रोग्रामिंग भाषा और उपयोगकर्ता के अनुकूल एपीआई का उपयोग करता है। यह एपीआई आपको अपने डेटा के साथ खेलने की अनुमति देता है, जो कि अगले भाग का विषय है।

संग्रह और दस्तावेज़ बनाना

MongoDB डेटाबेस दस्तावेज़ों के संग्रह के लिए एक भौतिक कंटेनर है। प्रत्येक डेटाबेस को फाइल सिस्टम पर फाइलों का अपना सेट मिलता है। इन फ़ाइलों को MongoDB सर्वर द्वारा प्रबंधित किया जाता है, जो कई डेटाबेस को संभाल सकता है।

MongoDB में, एक संग्रह दस्तावेजों . का एक समूह है . संग्रह कुछ हद तक पारंपरिक आरडीबीएमएस में तालिकाओं के समान हैं, लेकिन एक कठोर स्कीमा लगाए बिना। सिद्धांत रूप में, संग्रह के प्रत्येक दस्तावेज़ में एक पूरी तरह से अलग संरचना या फ़ील्ड का सेट हो सकता है।

व्यवहार में, एक संग्रह में दस्तावेज़ समान रूप से पुनर्प्राप्ति, सम्मिलन और अद्यतन प्रक्रियाओं की अनुमति देने के लिए समान संरचना साझा करते हैं। आप अद्यतन और सम्मिलन के दौरान दस्तावेज़ सत्यापन नियमों का उपयोग करके एक समान दस्तावेज़ संरचना लागू कर सकते हैं।

विभिन्न दस्तावेज़ संरचनाओं की अनुमति देना MongoDB संग्रह की एक प्रमुख विशेषता है। यह सुविधा लचीलापन प्रदान करती है और औपचारिक तालिका स्कीमा को संशोधित किए बिना दस्तावेज़ों में नए फ़ील्ड जोड़ने की अनुमति देती है।

mongo . का उपयोग करके संग्रह बनाने के लिए खोल, आपको db को इंगित करने की आवश्यकता है अपने लक्ष्य डेटाबेस में और फिर डॉट नोटेशन . का उपयोग करके संग्रह बनाएं :

> use rptutorials
switched to db rptutorials
> db
rptutorials
> db.tutorial
rptutorials.tutorial

इस उदाहरण में, आप tutorial . बनाने के लिए डॉट नोटेशन का उपयोग करते हैं rptutorials . में संग्रह के रूप में , जो आपका वर्तमान डेटाबेस है। यह ध्यान रखना महत्वपूर्ण है कि MongoDB डेटाबेस और संग्रह बनाता है आलसी . दूसरे शब्दों में, वे आपके द्वारा पहला दस्तावेज़ डालने के बाद ही भौतिक रूप से बनाए जाते हैं।

एक बार आपके पास डेटाबेस और संग्रह हो जाने के बाद, आप दस्तावेज़ सम्मिलित करना प्रारंभ कर सकते हैं। दस्तावेज़ MongoDB में भंडारण की इकाई हैं। RDBMS में, यह एक टेबल रो के बराबर होगा। हालाँकि, MongoDB के दस्तावेज़ पंक्तियों की तुलना में अधिक बहुमुखी हैं क्योंकि वे जटिल जानकारी, जैसे कि सरणियाँ, एम्बेडेड दस्तावेज़ और यहाँ तक कि दस्तावेज़ों की सरणियाँ संग्रहीत कर सकते हैं।

MongoDB दस्तावेज़ों को बाइनरी JSON . नामक प्रारूप में संग्रहीत करता है (बीएसओएन), जो जेएसओएन का द्विआधारी प्रतिनिधित्व है। MongoDB के दस्तावेज़ फ़ील्ड-एंड-वैल्यू पेयर से बने होते हैं और इनकी संरचना निम्नलिखित होती है:

{
   field1 → value1,
   field2 → value2,
   field3 → value3,
   ...
   fieldN → valueN
}

किसी फ़ील्ड का मान कोई भी BSON डेटा प्रकार हो सकता है, जिसमें अन्य दस्तावेज़, सरणियाँ और दस्तावेज़ों की सरणियाँ शामिल हैं। व्यवहार में, आप JSON प्रारूप का उपयोग करके अपने दस्तावेज़ निर्दिष्ट करेंगे।

जब आप एक MongoDB डेटाबेस एप्लिकेशन बना रहे होते हैं, तो शायद आपका सबसे महत्वपूर्ण निर्णय दस्तावेज़ों की संरचना के बारे में होता है। दूसरे शब्दों में, आपको यह तय करना होगा कि आपके दस्तावेज़ों में कौन से फ़ील्ड और मूल्य होंगे।

आपकी पायथन साइट के लिए ट्यूटोरियल के मामले में, आपके दस्तावेज़ इस तरह संरचित हो सकते हैं:

{
    "title": "Reading and Writing CSV Files in Python",
    "author": "Jon",
    "contributors": [
        "Aldren",
        "Geir Arne",
        "Joanna",
        "Jason"
    ],
    "url": "https://realpython.com/python-csv/"
}

एक दस्तावेज़ अनिवार्य रूप से संपत्ति के नाम और उनके मूल्यों का एक समूह है। मान सरल डेटा प्रकार हो सकते हैं, जैसे तार और संख्याएं, लेकिन वे सरणी भी हो सकते हैं जैसे contributors उपरोक्त उदाहरण में।

MongoDB का दस्तावेज़-उन्मुख डेटा मॉडल स्वाभाविक रूप से एक एकल वस्तु के रूप में जटिल डेटा का प्रतिनिधित्व करता है। यह आपको कई स्थानों या तालिकाओं को देखे बिना डेटा ऑब्जेक्ट के साथ समग्र रूप से काम करने की अनुमति देता है।

यदि आप अपने ट्यूटोरियल को स्टोर करने के लिए पारंपरिक आरडीबीएमएस का उपयोग कर रहे थे, तो संभवतः आपके पास अपने ट्यूटोरियल स्टोर करने के लिए एक टेबल और आपके योगदानकर्ताओं को स्टोर करने के लिए एक और टेबल होगी। फिर आपको दोनों तालिकाओं के बीच एक संबंध स्थापित करना होगा ताकि आप बाद में डेटा पुनः प्राप्त कर सकें।

संग्रहों और दस्तावेज़ों के साथ कार्य करना

अब तक, आप mongo . को चलाने और उपयोग करने की मूल बातें जानते हैं सीप। आप यह भी जानते हैं कि JSON प्रारूप का उपयोग करके अपने स्वयं के दस्तावेज़ कैसे बनाएं। अब यह सीखने का समय है कि अपने MongoDB डेटाबेस में दस्तावेज़ कैसे डालें।

mongo . का उपयोग करके किसी दस्तावेज़ को डेटाबेस में सम्मिलित करने के लिए खोल, आपको पहले एक संग्रह चुनना होगा और फिर .insertOne() . पर कॉल करना होगा एक तर्क के रूप में अपने दस्तावेज़ के साथ संग्रह पर:

> use rptutorials
switched to db rptutorials

> db.tutorial.insertOne({
...     "title": "Reading and Writing CSV Files in Python",
...     "author": "Jon",
...     "contributors": [
...         "Aldren",
...         "Geir Arne",
...         "Joanna",
...         "Jason"
...     ],
...     "url": "https://realpython.com/python-csv/"
... })
{
    "acknowledged" : true,
    "insertedId" : ObjectId("600747355e6ea8d224f754ba")
}

पहले आदेश के साथ, आप उस डेटाबेस पर स्विच करते हैं जिसका आप उपयोग करना चाहते हैं। दूसरा आदेश एक जावास्क्रिप्ट विधि कॉल है जो चयनित संग्रह में एक साधारण दस्तावेज़ सम्मिलित करता है, tutorial . एक बार जब आप Enter दबाएं , आपको अपनी स्क्रीन पर एक संदेश मिलता है जो आपको नए सम्मिलित किए गए दस्तावेज़ और उसके insertedId के बारे में सूचित करता है ।

जैसे संबंधपरक डेटाबेस को तालिका में प्रत्येक पंक्ति को विशिष्ट रूप से पहचानने के लिए प्राथमिक कुंजी की आवश्यकता होती है, वैसे ही MongoDB दस्तावेज़ों में _id होना चाहिए फ़ील्ड जो विशिष्ट रूप से दस्तावेज़ की पहचान करती है। MongoDB आपको एक कस्टम _id . दर्ज करने की अनुमति देता है जब तक आप इसकी विशिष्टता की गारंटी देते हैं। हालांकि, एक व्यापक रूप से स्वीकृत अभ्यास MongoDB को स्वचालित रूप से एक _id . डालने की अनुमति देना है आपके लिए।

इसी तरह, आप .insertMany() . का उपयोग करके एक बार में कई दस्तावेज़ जोड़ सकते हैं :

> tutorial1 = {
...     "title": "How to Iterate Through a Dictionary in Python",
...     "author": "Leodanis",
...     "contributors": [
...         "Aldren",
...         "Jim",
...         "Joanna"
...     ],
...     "url": "https://realpython.com/iterate-through-dictionary-python/"
... }

> tutorial2 = {
...      "title": "Python 3's f-Strings: An Improved String Formatting Syntax",
...      "author": "Joanna",
...      "contributors": [
...          "Adriana",
...          "David",
...          "Dan",
...          "Jim",
...          "Pavel"
...      ],
...      "url": "https://realpython.com/python-f-strings/"
... }

> db.tutorial.insertMany([tutorial1, tutorial2])
{
    "acknowledged" : true,
    "insertedIds" : [
        ObjectId("60074ff05e6ea8d224f754bb"),
        ObjectId("60074ff05e6ea8d224f754bc")
    ]
}

यहां, .insertMany() . पर कॉल करें ट्यूटोरियल की एक सूची लेता है और उन्हें डेटाबेस में सम्मिलित करता है। फिर से, शेल आउटपुट नए डाले गए दस्तावेज़ों और उनके स्वचालित रूप से जोड़े गए _id . के बारे में जानकारी दिखाता है फ़ील्ड।

mongo शेल डेटाबेस पर रीड, अपडेट और डिलीट ऑपरेशन करने के तरीके भी प्रदान करता है। उदाहरण के लिए, आप .find() . का उपयोग कर सकते हैं संग्रह में दस्तावेज़ों को पुनः प्राप्त करने के लिए:

> db.tutorial.find()
{ "_id" : ObjectId("600747355e6ea8d224f754ba"),
"title" : "Reading and Writing CSV Files in Python",
"author" : "Jon",
"contributors" : [ "Aldren", "Geir Arne", "Joanna", "Jason" ],
"url" : "https://realpython.com/python-csv/" }
    ...

> db.tutorial.find({author: "Joanna"})
{ "_id" : ObjectId("60074ff05e6ea8d224f754bc"),
"title" : "Python 3's f-Strings: An Improved String Formatting Syntax (Guide)",
"author" : "Joanna",
"contributors" : [ "Adriana", "David", "Dan", "Jim", "Pavel" ],
"url" : "https://realpython.com/python-f-strings/" }

.find() . पर पहली कॉल tutorial . में सभी दस्तावेज़ों को पुनः प्राप्त करता है संग्रह। दूसरी ओर, दूसरी कॉल .find() . पर है जोआना द्वारा लिखित उन ट्यूटोरियल को पुनः प्राप्त करता है।

अपने mongo . के माध्यम से MongoDB का उपयोग करने के बारे में इस पृष्ठभूमि के ज्ञान के साथ शेल, आप पायथन के साथ MongoDB का उपयोग शुरू करने के लिए तैयार हैं। अगले कुछ खंड आपको अपने पायथन अनुप्रयोगों में MongoDB डेटाबेस का उपयोग करने के लिए विभिन्न विकल्पों के बारे में बताएंगे।

पायथन और पायमोंगो के साथ MongoDB का उपयोग करना

अब जब आप जानते हैं कि MongoDB क्या है और mongo . का उपयोग करके डेटाबेस कैसे बनाएं और प्रबंधित करें? खोल, आप MongoDB का उपयोग शुरू कर सकते हैं, लेकिन इस बार पायथन के साथ। MongoDB PyMongo नामक एक आधिकारिक पायथन ड्राइवर प्रदान करता है।

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

PyMongo के भीतर प्रत्येक मॉड्यूल डेटाबेस पर संचालन के एक सेट के लिए जिम्मेदार है। आपके पास कम से कम निम्नलिखित कार्यों के लिए मॉड्यूल होंगे:

• डेटाबेस कनेक्शन स्थापित करना
• डेटाबेस के साथ काम करना
• संग्रहों और दस्तावेज़ों के साथ काम करना
• कर्सर में हेरफेर करना
• डेटा एन्क्रिप्शन के साथ काम करना

सामान्य तौर पर, PyMongo उपकरणों का एक समृद्ध सेट प्रदान करता है जिसका उपयोग आप MongoDB सर्वर के साथ संचार करने के लिए कर सकते हैं। यह क्वेरी करने, परिणाम पुनर्प्राप्त करने, डेटा लिखने और हटाने और डेटाबेस कमांड चलाने के लिए कार्यक्षमता प्रदान करता है।

पायमोंगो स्थापित करना

PyMongo का उपयोग शुरू करने के लिए, आपको सबसे पहले इसे अपने Python वातावरण में स्थापित करना होगा। आप वर्चुअल वातावरण का उपयोग कर सकते हैं, या आप अपने सिस्टम-वाइड पायथन इंस्टॉलेशन का उपयोग कर सकते हैं, हालांकि पहला विकल्प पसंद किया जाता है। PyMongo, PyPI पर उपलब्ध है, इसलिए इसे स्थापित करने का सबसे तेज़ तरीका pip . है . अपने टर्मिनल को सक्रिय करें और निम्न कमांड चलाएँ:

$ pip install pymongo==3.11.2

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

नोट: PyMongo को स्थापित करने के तरीके के बारे में पूरी गाइड के लिए, इसके आधिकारिक दस्तावेज़ीकरण का इंस्टालेशन/अपग्रेडिंग पेज देखें।

एक बार जब आप इंस्टालेशन के साथ कर लेते हैं, तो आप एक पायथन इंटरेक्टिव सत्र शुरू कर सकते हैं और निम्नलिखित आयात चला सकते हैं:

>>> import pymongo

यदि यह पाइथन खोल में अपवाद उठाए बिना चलता है, तो आपकी स्थापना ठीक काम करती है। यदि नहीं, तो ध्यानपूर्वक चरणों को फिर से करें।

कनेक्शन स्थापित करना

डेटाबेस से कनेक्शन स्थापित करने के लिए, आपको एक MongoClient create बनाना होगा उदाहरण। यह वर्ग एक MongoDB उदाहरण या सर्वर के लिए क्लाइंट प्रदान करता है। प्रत्येक क्लाइंट ऑब्जेक्ट में एक अंतर्निहित कनेक्शन पूल होता है, जो डिफ़ॉल्ट रूप से सर्वर से सौ कनेक्शन तक संभालता है।

अपने पायथन इंटरैक्टिव सत्र पर वापस जाएं और आयात करें MongoClient pymongo . से . फिर अपने वर्तमान में चल रहे MongoDB उदाहरण के साथ संचार करने के लिए क्लाइंट ऑब्जेक्ट बनाएं:

>>> from pymongo import MongoClient
>>> client = MongoClient()
>>> client
MongoClient(host=['localhost:27017'], ..., connect=True)

ऊपर दिया गया कोड डिफ़ॉल्ट होस्ट (localhost . से कनेक्शन स्थापित करता है ) और पोर्ट (27017 .) ) MongoClient तर्कों का एक सेट लेता है जो आपको कस्टम होस्ट, पोर्ट और अन्य कनेक्शन पैरामीटर निर्दिष्ट करने की अनुमति देता है। उदाहरण के लिए, एक कस्टम होस्ट और पोर्ट प्रदान करने के लिए, आप निम्न कोड का उपयोग कर सकते हैं:

>>> client = MongoClient(host="localhost", port=27017)

यह तब आसान होता है जब आपको host . प्रदान करने की आवश्यकता होती है और port जो MongoDB के डिफ़ॉल्ट सेटअप से अलग है। आप MongoDB URI प्रारूप का भी उपयोग कर सकते हैं:

>>> client = MongoClient("mongodb://localhost:27017")

MongoClient . के ये सभी उदाहरण अपने वर्तमान MongoDB उदाहरण को जोड़ने के लिए समान क्लाइंट सेटअप प्रदान करें। आपको किसका उपयोग करना चाहिए यह इस बात पर निर्भर करता है कि आप अपने कोड में कितना स्पष्ट होना चाहते हैं।

एक बार जब आप MongoClient . को इंस्टेंट कर लेते हैं , आप इसके उदाहरण का उपयोग उस विशिष्ट डेटाबेस कनेक्शन को संदर्भित करने के लिए कर सकते हैं, जैसे आपने mongo के साथ किया था शेल का db उपरोक्त खंड में वस्तु।

डेटाबेस, संग्रह और दस्तावेज़ों के साथ कार्य करना

एक बार जब आपके पास MongoClient . का कनेक्टेड इंस्टेंस हो जाए , आप निर्दिष्ट मोंगोडीबी सर्वर द्वारा प्रबंधित किसी भी डेटाबेस तक पहुंच सकते हैं। यह परिभाषित करने के लिए कि आप किस डेटाबेस का उपयोग करना चाहते हैं, आप डॉट नोटेशन का उपयोग वैसे ही कर सकते हैं जैसे आपने mongo में किया था खोल:

>>> db = client.rptutorials
>>> db
Database(MongoClient(host=['localhost:27017'], ..., connect=True), 'rptutorials')

इस मामले में, rptutorials उस डेटाबेस का नाम है जिसके साथ आप काम करेंगे। यदि डेटाबेस मौजूद नहीं है, तो MongoDB इसे आपके लिए बनाता है, लेकिन केवल तभी जब आप डेटाबेस पर पहला ऑपरेशन करते हैं।

यदि डेटाबेस का नाम मान्य पायथन पहचानकर्ता नहीं है, तो आप डिक्शनरी-स्टाइल एक्सेस का भी उपयोग कर सकते हैं:

>>> db = client["rptutorials"]

यह कथन तब आसान होता है जब आपके डेटाबेस का नाम मान्य पायथन पहचानकर्ता नहीं होता है। उदाहरण के लिए, यदि आपके डेटाबेस को rp-tutorials . कहा जाता है , तो आपको डिक्शनरी-स्टाइल एक्सेस का उपयोग करने की आवश्यकता है।

नोट: जब आप mongo . का उपयोग करते हैं खोल, आपके पास db . के माध्यम से डेटाबेस तक पहुंच है वैश्विक वस्तु। जब आप PyMongo का उपयोग करते हैं, तो आप डेटाबेस को db . नामक एक वैरिएबल को असाइन कर सकते हैं समान व्यवहार पाने के लिए।

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

>>> tutorial1 = {
...     "title": "Working With JSON Data in Python",
...     "author": "Lucas",
...     "contributors": [
...         "Aldren",
...         "Dan",
...         "Joanna"
...     ],
...     "url": "https://realpython.com/python-json/"
... }

एक बार जब आप एक शब्दकोश के रूप में दस्तावेज़ बना लेते हैं, तो आपको यह निर्दिष्ट करना होगा कि आप किस संग्रह का उपयोग करना चाहते हैं। ऐसा करने के लिए, आप डेटाबेस ऑब्जेक्ट पर डॉट नोटेशन का उपयोग कर सकते हैं:

>>> tutorial = db.tutorial
>>> tutorial
Collection(Database(..., connect=True), 'rptutorials'), 'tutorial')

इस मामले में, tutorial Collection का एक उदाहरण है और आपके डेटाबेस में दस्तावेज़ों के भौतिक संग्रह का प्रतिनिधित्व करता है। आप tutorial . में दस्तावेज़ सम्मिलित कर सकते हैं .insert_one() . पर कॉल करके उस पर एक तर्क के रूप में एक दस्तावेज़ के साथ:

>>> result = tutorial.insert_one(tutorial1)
>>> result
<pymongo.results.InsertOneResult object at 0x7fa854f506c0>

>>> print(f"One tutorial: {result.inserted_id}")
One tutorial: 60084b7d87eb0fbf73dbf71d

यहां, .insert_one() tutorial1 takes लेता है , इसे tutorial . में सम्मिलित करता है संग्रह करता है और एक InsertOneResult लौटाता है वस्तु। यह ऑब्जेक्ट सम्मिलित दस्तावेज़ पर प्रतिक्रिया प्रदान करता है। ध्यान दें कि चूंकि MongoDB ObjectId . उत्पन्न करता है गतिशील रूप से, आपका आउटपुट ObjectId . से मेल नहीं खाएगा ऊपर दिखाया गया है।

यदि आपके पास डेटाबेस में जोड़ने के लिए कई दस्तावेज़ हैं, तो आप .insert_many() का उपयोग कर सकते हैं उन्हें एक बार में सम्मिलित करने के लिए:

>>> tutorial2 = {
...     "title": "Python's Requests Library (Guide)",
...     "author": "Alex",
...     "contributors": [
...         "Aldren",
...         "Brad",
...         "Joanna"
...     ],
...     "url": "https://realpython.com/python-requests/"
... }

>>> tutorial3 = {
...     "title": "Object-Oriented Programming (OOP) in Python 3",
...     "author": "David",
...     "contributors": [
...         "Aldren",
...         "Joanna",
...         "Jacob"
...     ],
...     "url": "https://realpython.com/python3-object-oriented-programming/"
... }

>>> new_result = tutorial.insert_many([tutorial2, tutorial3])

>>> print(f"Multiple tutorials: {new_result.inserted_ids}")
Multiple tutorials: [
   ObjectId('6008511c87eb0fbf73dbf71e'),
   ObjectId('6008511c87eb0fbf73dbf71f')
]

यह .insert_one() . को कॉल करने की तुलना में तेज़ और आसान है कई बार। .insert_many() . पर कॉल करें पुनरावर्तनीय दस्तावेज़ों को लेता है और उन्हें tutorial . में सम्मिलित करता है आपके rptutorials . में संग्रह डेटाबेस। यह विधि InsertManyResult का एक उदाहरण लौटाती है , जो सम्मिलित दस्तावेजों के बारे में जानकारी प्रदान करता है।

किसी संग्रह से दस्तावेज़ पुनर्प्राप्त करने के लिए, आप .find() . का उपयोग कर सकते हैं . तर्कों के बिना, .find() एक Cursor देता है ऑब्जेक्ट जो मांग पर संग्रह में दस्तावेज़ देता है:

>>> import pprint

>>> for doc in tutorial.find():
...     pprint.pprint(doc)
...
{'_id': ObjectId('600747355e6ea8d224f754ba'),
 'author': 'Jon',
 'contributors': ['Aldren', 'Geir Arne', 'Joanna', 'Jason'],
 'title': 'Reading and Writing CSV Files in Python',
 'url': 'https://realpython.com/python-csv/'}
    ...
{'_id': ObjectId('6008511c87eb0fbf73dbf71f'),
 'author': 'David',
 'contributors': ['Aldren', 'Joanna', 'Jacob'],
 'title': 'Object-Oriented Programming (OOP) in Python 3',
 'url': 'https://realpython.com/python3-object-oriented-programming/'}

Here, you run a loop on the object that .find() returns and print successive results, using pprint.pprint() to provide a user-friendly output format.

You can also use .find_one() to retrieve a single document. In this case, you can use a dictionary that contains fields to match. For example, if you want to retrieve the first tutorial by Jon, then you can do something like this:

>>> import pprint

>>> jon_tutorial = tutorial.find_one({"author": "Jon"})

>>> pprint.pprint(jon_tutorial)
{'_id': ObjectId('600747355e6ea8d224f754ba'),
 'author': 'Jon',
 'contributors': ['Aldren', 'Geir Arne', 'Joanna', 'Jason'],
 'title': 'Reading and Writing CSV Files in Python',
 'url': 'https://realpython.com/python-csv/'}

Note that the tutorial’s ObjectId is set under the _id key, which is the unique document identifier that MongoDB automatically adds when you insert a document into your database.

PyMongo also provides methods to replace, update, and delete documents from a database. If you want to dive deeper into these features, then take a look at the documentation for Collection ।

Closing Connections

Establishing a connection to a MongoDB database is typically an expensive operation. If you have an application that constantly retrieves and manipulates data in a MongoDB database, then you probably don’t want to be opening and closing the connection all the time since this might affect your application’s performance.

In this kind of situation, you should keep your connection alive and only close it before exiting the application to clear all the acquired resources. You can close the connection by calling .close() on the MongoClient instance:

>>> client.close()

Another situation is when you have an application that occasionally uses a MongoDB database. In this case, you might want to open the connection when needed and close it immediately after use for freeing the acquired resources. A consistent approach to this problem would be to use the with बयान। Yes, MongoClient implements the context manager protocol:

>>> import pprint
>>> from pymongo import MongoClient

>>> with MongoClient() as client:
...     db = client.rptutorials
...     for doc in db.tutorial.find():
...         pprint.pprint(doc)
...
{'_id': ObjectId('600747355e6ea8d224f754ba'),
 'author': 'Jon',
 'contributors': ['Aldren', 'Geir Arne', 'Joanna', 'Jason'],
 'title': 'Reading and Writing CSV Files in Python',
 'url': 'https://realpython.com/python-csv/'}
    ...
{'_id': ObjectId('6008511c87eb0fbf73dbf71f'),
 'author': 'David',
 'contributors': ['Aldren', 'Joanna', 'Jacob'],
 'title': 'Object-Oriented Programming (OOP) in Python 3',
 'url': 'https://realpython.com/python3-object-oriented-programming/'}

If you use the with statement to handle your MongoDB client, then at the end of the with code block, the client’s .__exit__() method gets called, which at the same time closes the connection by calling .close() ।

Using MongoDB With Python and MongoEngine

While PyMongo is a great and powerful Python driver for interfacing with MongoDB, it’s probably a bit too low-level for many of your projects. With PyMongo, you’ll have to write a lot of code to consistently insert, retrieve, update, and delete documents.

One library that provides a higher abstraction on top of PyMongo is MongoEngine. MongoEngine is an object-document mapper (ODM), which is roughly equivalent to an SQL-based object-relational mapper (ORM). MongoEngine provides a class-based abstraction, so all the models you create are classes.

Installing MongoEngine

There are a handful of Python libraries to help you work with MongoDB. MongoEngine, however, is a popular one that provides a nice set of features, flexibility, and community support. MongoEngine is available on PyPI. You can install it using the following pip आदेश:

$ pip install mongoengine==0.22.1

Once you’ve installed MongoEngine into your Python environment, you’re ready to start working with MongoDB databases using Python’s object-oriented features. The next step is to connect to your running MongoDB instance.

Establishing a Connection

To establish a connection with your database, you need to use mongoengine.connect() . This function takes several arguments. However, in this tutorial, you’ll use only three of them. Within your Python interactive session, type the following code:

>>> from mongoengine import connect
>>> connect(db="rptutorials", host="localhost", port=27017)
MongoClient(host=['localhost:27017'], ..., read_preference=Primary())

Here, you first set the database name db to "rptutorials" , which is the name of the database you want to work in. Then you provide a host and a port to connect to your current MongoDB instance. Since you’re using the default host and port , you can omit these two parameters and just use connect("rptutorials") ।

Working With Collections and Documents

To create documents with MongoEngine, you first need to define what data you want the documents to have. In other words, you need to define a document schema. MongoEngine encourages you to define a document schema to help you reduce coding errors and to allow you to define utility or helper methods.

Similar to ORMs, ODMs like MongoEngine provide a base or model class for you to define a document schema. In ORMs, that class is equivalent to a table, and its instances are equivalent to rows. In MongoEngine, the class is equivalent to a collection, and its instances are equivalent to documents.

To create a model, you need to subclass Document and provide the required fields as class attributes. To continue with the blog example, here’s how you can create a model for your tutorials:

>>> from mongoengine import Document, ListField, StringField, URLField

>>> class Tutorial(Document):
...     title = StringField(required=True, max_length=70)
...     author = StringField(required=True, max_length=20)
...     contributors = ListField(StringField(max_length=20))
...     url = URLField(required=True)

With this model, you tell MongoEngine that you expect a Tutorial document to have a .title , an .author , a list of .contributors , and a .url . The base class, Document , uses that information along with the field types to validate the input data for you.

नोट: One of the more difficult tasks with database models is data validation . How do you make sure that the input data conforms to your format requirements? That’s one of the reasons for you to have a coherent and uniform document schema.

MongoDB is said to be a schemaless database, but that doesn’t mean it’s schema free. Having documents with a different schema within the same collection can lead to processing errors and inconsistent behavior.

For example, if you try to save a Tutorial object without a .title , then your model throws an exception and lets you know. You can take this even further and add more restrictions, such as the length of the .title , and so on.

There are a few general parameters that you can use to validate fields. Here are some of the more commonly used parameters:

• db_field specifies a different field name.
• required ensures that the field is provided.
• default provides a default value for a given field if no value is given.
• unique ensures that no other document in the collection has the same value for this field.

Each specific field type also has its own set of parameters. You can check the documentation for a complete guide to the available field types.

To save a document to your database, you need to call .save() on a document object. If the document already exists, then all the changes will be applied to the existing document. If the document doesn’t exist, then it’ll be created.

Here’s an example of creating and saving a tutorial into your sample tutorials database:

>>> tutorial1 = Tutorial(
...     title="Beautiful Soup: Build a Web Scraper With Python",
...     author="Martin",
...     contributors=["Aldren", "Geir Arne", "Jaya", "Joanna", "Mike"],
...     url="https://realpython.com/beautiful-soup-web-scraper-python/"
... )

>>> tutorial1.save()  # Insert the new tutorial
<Tutorial: Tutorial object>

By default, .save() inserts the new document into a collection named after the model class, Tutorial , except using lowercase letters. In this case, the collection name is tutorial , which matches the collection you’ve been using to save your tutorials.

PyMongo performs data validation when you call .save() . This means that it checks the input data against the schema you declared in the Tutorial model class. If the input data violates the schema or any of its constraints, then you get an exception, and the data isn’t saved into the database.

For example, here’s what happens if you try to save a tutorial without providing a .title :

>>> tutorial2 = Tutorial()
>>> tutorial2.author = "Alex"
>>> tutorial2.contributors = ["Aldren", "Jon", "Joanna"]
>>> tutorial2.url = "https://realpython.com/convert-python-string-to-int/"
>>> tutorial2.save()
Traceback (most recent call last):
  ...
mongoengine.errors.ValidationError: ... (Field is required: ['title'])

In this example, first note that you can also build a Tutorial object by assigning values to its attributes. Second, since you don’t provide a .title for the new tutorial, .save() raises a ValidationError telling you that the .title field is required. Having automatic data validation is a great feature that will save you some headaches.

Each Document subclass has an .objects attribute that you can use to access the documents in the associated collection. For example, here’s how you can print the .title of all your current tutorials:

>>> for doc in Tutorial.objects:
...     print(doc.title)
...
Reading and Writing CSV Files in Python
How to Iterate Through a Dictionary in Python
Python 3's f-Strings: An Improved String Formatting Syntax (Guide)
Working With JSON Data in Python
Python's Requests Library (Guide)
Object-Oriented Programming (OOP) in Python 3
Beautiful Soup: Build a Web Scraper With Python

The for loop iterates over all your tutorials and prints their .title data to the screen. You can also use .objects to filter your documents. For example, say you want to retrieve the tutorials authored by Alex. In that case, you can do something like this:

>>> for doc in Tutorial.objects(author="Alex"):
...     print(doc.title)
...
Python's Requests Library (Guide)

MongoEngine is well suited to manage your MongoDB databases for just about any type of application. Its features make it ideal for creating efficient and scalable programs using a high-level approach. If you’re looking for more information about MongoEngine, be sure to check out its user guide.

Conclusion

If you need a robust, scalable, and flexible database solution, then MongoDB might be a good option for you. MongoDB is a mature and popular NoSQL database with great Python support. With a good understanding of how to access MongoDB with Python, you’ll be ready to create database applications that scale well and provide excellent performance.

With MongoDB, you also have the benefit of a human-readable and highly-flexible data model, so you can adapt to requirement changes quickly.

In this tutorial, you learned:

• What MongoDB and NoSQL databases are
• How to install and run MongoDB on your system
• How to create and work with MongoDB databases
• How to interface with MongoDB in Python using the PyMongo driver
• How to use the MongoEngine object-document mapper to work with MongoDB

The examples you coded in this tutorial are available for download. To get their source code, click the link below:

Get the Source Code: Click here to get the source code you’ll use to learn about using MongoDB with Python in this tutorial.