MongoDB - त्वरित गाइड

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

डेटाबेस

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

संग्रह

संग्रह MongoDB दस्तावेजों का एक समूह है। यह RDBMS तालिका के समतुल्य है। एक डेटाबेस में एक संग्रह मौजूद है। संग्रह एक स्कीमा लागू नहीं करते हैं। एक संग्रह के भीतर दस्तावेजों में विभिन्न क्षेत्र हो सकते हैं। आमतौर पर, एक संग्रह में सभी दस्तावेज समान या संबंधित उद्देश्य के होते हैं।

डाक्यूमेंट

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

निम्नलिखित तालिका MongoDB के साथ RDBMS शब्दावली का संबंध दर्शाती है।

आरडीबीएमएस MongoDB
डेटाबेस डेटाबेस
टेबल संग्रह
टपल / पंक्ति डाक्यूमेंट
स्तंभ मैदान
तालिका में शामिल हों एंबेडेड दस्तावेज़
प्राथमिक कुंजी प्राथमिक कुंजी (डिफ़ॉल्ट कुंजी _id जो मोंगोडब द्वारा प्रदान की गई है)
डेटाबेस सर्वर और ग्राहक
Mysqld / ओरेकल mongod
mysql / sqlplus मोंगो

नमूना दस्तावेज़

निम्नलिखित उदाहरण एक ब्लॉग साइट के दस्तावेज़ संरचना को दर्शाता है, जो कि बस एक अल्पविराम द्वारा अलग किया गया महत्वपूर्ण मान है।

{
   _id: ObjectId(7df78ad8902c)
   title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by: 'tutorials point',
   url: 'http://www.tutorialspoint.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100, 
   comments: [	
      {
         user:'user1',
         message: 'My first comment',
         dateCreated: new Date(2011,1,20,2,15),
         like: 0 
      },
      {
         user:'user2',
         message: 'My second comments',
         dateCreated: new Date(2011,1,25,7,45),
         like: 5
      }
   ]
}

_idएक 12 बाइट्स हेक्साडेसिमल संख्या है जो हर दस्तावेज की विशिष्टता का आश्वासन देती है। दस्तावेज़ को सम्मिलित करते समय आप _id प्रदान कर सकते हैं। यदि आप प्रदान नहीं करते हैं तो MongoDB हर दस्तावेज़ के लिए एक अद्वितीय आईडी प्रदान करता है। मौजूदा टाइमस्टैम्प के लिए ये 12 बाइट्स पहले 4 बाइट्स, मशीन आईडी के लिए अगले 3 बाइट्स, मोंगोबीडीई सर्वर की प्रक्रिया आईडी के लिए अगले 2 बाइट्स और शेष 3 बाइट्स साधारण वृद्धिशील मूल्य हैं।

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

RDBMS पर MongoDB के लाभ

  • Schema less- MongoDB एक डॉक्यूमेंट डेटाबेस है जिसमें एक संग्रह अलग-अलग दस्तावेज़ रखता है। दस्तावेज़ की फ़ील्ड, सामग्री और आकार की संख्या एक दस्तावेज़ से दूसरे में भिन्न हो सकती है।

  • एकल वस्तु की संरचना स्पष्ट है।

  • कोई जटिल जुड़ता है।

  • गहरी क्वेरी-क्षमता। MongoDB दस्तावेज़-आधारित क्वेरी भाषा का उपयोग करते हुए दस्तावेज़ों पर गतिशील प्रश्नों का समर्थन करता है जो SQL के रूप में लगभग शक्तिशाली हैं।

  • Tuning.

  • Ease of scale-out - MongoDB को स्केल करना आसान है।

  • डेटाबेस ऑब्जेक्ट के लिए एप्लिकेशन ऑब्जेक्ट का रूपांतरण / मानचित्रण आवश्यक नहीं है।

  • डेटा के तेजी से उपयोग को सक्षम करने, सेट (काम) विंडो को संग्रहीत करने के लिए आंतरिक मेमोरी का उपयोग करता है।

क्यों MongoDB का उपयोग करें?

  • Document Oriented Storage - डेटा को JSON शैली के दस्तावेज़ों के रूप में संग्रहीत किया जाता है।

  • किसी भी विशेषता पर सूचकांक

  • प्रतिकृति और उच्च उपलब्धता

  • Auto-sharding

  • समृद्ध प्रश्न

  • फास्ट इन-प्लेस अपडेट

  • MongoDB द्वारा व्यावसायिक सहायता

MongoDB का उपयोग कहां करें?

  • बड़ा डाटा
  • सामग्री प्रबंधन और वितरण
  • मोबाइल और सोशल इन्फ्रास्ट्रक्चर
  • उपयोगकर्ता डेटा प्रबंधन
  • डाटा हब

आइए अब देखते हैं कि विंडोज पर MongoDB कैसे स्थापित करें।

विंडोज पर MongoDB स्थापित करें

विंडोज पर MongoDB स्थापित करने के लिए, पहले MongoDB की नवीनतम रिलीज़ को डाउनलोड करें https://www.mongodb.org/downloads। सुनिश्चित करें कि आपको अपने Windows संस्करण के आधार पर MongoDB का सही संस्करण प्राप्त हो। अपना विंडोज संस्करण प्राप्त करने के लिए, कमांड प्रॉम्प्ट खोलें और निम्न कमांड निष्पादित करें।

C:\>wmic os get osarchitecture
OSArchitecture
64-bit
C:\>

MongoDB के 32-बिट संस्करण केवल 2GB से छोटे डेटाबेस का समर्थन करते हैं और केवल परीक्षण और मूल्यांकन उद्देश्यों के लिए उपयुक्त हैं।

अब अपनी डाउनलोड की गई फ़ाइल को c: \ ड्राइव या किसी अन्य स्थान पर निकालें। सुनिश्चित करें कि निकाले गए फ़ोल्डर का नाम mongodb-win32-i386- [संस्करण] या mongodb-win32-x86_64- [संस्करण] है। यहाँ [संस्करण] MongoDB डाउनलोड का संस्करण है।

अगला, कमांड प्रॉम्प्ट खोलें और निम्न कमांड चलाएं।

C:\>move mongodb-win64-* mongodb
   1 dir(s) moved.
C:\>

यदि आपने अलग-अलग स्थान पर MongoDB निकाला है, तो कमांड का उपयोग करके उस पथ पर जाएं cd FOLDER/DIR और अब ऊपर दी गई प्रक्रिया को चलाएं।

MongoDB को अपनी फ़ाइलों को संग्रहीत करने के लिए एक डेटा फ़ोल्डर की आवश्यकता होती है। MongoDB डेटा निर्देशिका के लिए डिफ़ॉल्ट स्थान c: \ data \ db है। तो आपको कमांड प्रॉम्प्ट का उपयोग करके इस फ़ोल्डर को बनाने की आवश्यकता है। निम्न आदेश अनुक्रम निष्पादित करें।

C:\>md data
C:\md data\db

यदि आपको एक अलग स्थान पर MongoDB स्थापित करना है, तो आपको इसके लिए एक वैकल्पिक मार्ग निर्दिष्ट करना होगा \data\db रास्ता तय करके dbpath में mongod.exe। उसी के लिए, निम्न आदेश जारी करें।

कमांड प्रॉम्प्ट में, MongoDB इंस्टॉलेशन फ़ोल्डर में मौजूद बिन डायरेक्टरी में नेविगेट करें। मान लीजिए मेरा इंस्टॉलेशन फोल्डर हैD:\set up\mongodb

C:\Users\XYZ>d:
D:\>cd "set up"
D:\set up>cd mongodb
D:\set up\mongodb>cd bin
D:\set up\mongodb\bin>mongod.exe --dbpath "d:\set up\mongodb\data"

यह दिखाएगा waiting for connections कंसोल आउटपुट पर संदेश, जो इंगित करता है कि mongod.exe प्रक्रिया सफलतापूर्वक चल रही है।

अब MongoDB चलाने के लिए, आपको एक और कमांड प्रॉम्प्ट खोलने और निम्नलिखित कमांड जारी करने की आवश्यकता है।

D:\set up\mongodb\bin>mongo.exe
MongoDB shell version: 2.4.6
connecting to: test
>db.test.save( { a: 1 } )
>db.test.find()
{ "_id" : ObjectId(5879b0f65a56a454), "a" : 1 }
>

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

D:\set up\mongodb\bin>mongod.exe --dbpath "d:\set up\mongodb\data" 
D:\set up\mongodb\bin>mongo.exe

Ubuntu पर MongoDB स्थापित करें

MongoDB सार्वजनिक GPG कुंजी आयात करने के लिए निम्नलिखित कमांड चलाएँ -

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 7F0CEB10

निम्नलिखित कमांड का उपयोग करके एक /etc/apt/source.list.d/mongodb.list फ़ाइल बनाएं।

echo 'deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen' 
   | sudo tee /etc/apt/sources.list.d/mongodb.list

अब रिपॉजिटरी को अद्यतन करने के लिए निम्नलिखित आदेश जारी करें -

sudo apt-get update

निम्नलिखित कमांड का उपयोग करके नेवॉन्ग को स्थापित करें -

apt-get install mongodb-10gen = 2.2.3

उपरोक्त स्थापना में, 2.2.3 वर्तमान में MongoDB संस्करण जारी किया गया है। हमेशा नवीनतम संस्करण स्थापित करना सुनिश्चित करें। अब MongoDB सफलतापूर्वक स्थापित हो गया है।

MongoDB प्रारंभ करें

sudo service mongodb start

बंद करो MongoDB

sudo service mongodb stop

MongoDB को पुनरारंभ करें

sudo service mongodb restart

MongoDB का उपयोग करने के लिए निम्नलिखित कमांड चलाएँ।

mongo

यह आपको MongoDB इंस्टेंस को चलाने के लिए कनेक्ट करेगा।

MongoDB मदद

आदेशों की एक सूची प्राप्त करने के लिए, टाइप करें db.help()MongoDB क्लाइंट में। यह आपको कमांड की एक सूची देगा जैसा कि निम्नलिखित स्क्रीनशॉट में दिखाया गया है।

MongoDB आँकड़े

MongoDB सर्वर के बारे में आँकड़े प्राप्त करने के लिए, कमांड टाइप करें db.stats()MongoDB क्लाइंट में। यह डेटाबेस का नाम, डेटाबेस में संग्रह और दस्तावेजों की संख्या दिखाएगा। कमांड का आउटपुट निम्न स्क्रीनशॉट में दिखाया गया है।

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

MongoDB में स्कीमा डिजाइन करते समय कुछ विचार

  • उपयोगकर्ता की आवश्यकताओं के अनुसार अपने स्कीमा को डिज़ाइन करें।

  • यदि आप उन्हें एक साथ उपयोग करेंगे, तो वस्तुओं को एक दस्तावेज़ में मिलाएं। अन्यथा उन्हें अलग करें (लेकिन सुनिश्चित करें कि जुड़ने की आवश्यकता नहीं होनी चाहिए)।

  • डेटा की नकल करें (लेकिन सीमित) क्योंकि समय की तुलना करने के लिए डिस्क स्थान सस्ता है।

  • लिखते समय जुड़ते हैं, पढ़ने पर नहीं।

  • सबसे अधिक उपयोग के मामलों के लिए अपने स्कीमा का अनुकूलन करें।

  • स्कीमा में जटिल एकत्रीकरण करें।

उदाहरण

मान लीजिए कि एक क्लाइंट को अपने ब्लॉग / वेबसाइट के लिए डेटाबेस डिज़ाइन की आवश्यकता है और RDBMS और MongoDB स्कीमा डिज़ाइन के बीच अंतर देखें। वेबसाइट की निम्नलिखित आवश्यकताएं हैं।

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

RDBMS स्कीमा में, उपरोक्त आवश्यकताओं के लिए डिज़ाइन में न्यूनतम तीन टेबल होंगे।

जबकि MongoDB स्कीमा में, डिज़ाइन में एक संग्रह पोस्ट और निम्न संरचना होगी -

{
   _id: POST_ID
   title: TITLE_OF_POST, 
   description: POST_DESCRIPTION,
   by: POST_BY,
   url: URL_OF_POST,
   tags: [TAG1, TAG2, TAG3],
   likes: TOTAL_LIKES, 
   comments: [	
      {
         user:'COMMENT_BY',
         message: TEXT,
         dateCreated: DATE_TIME,
         like: LIKES 
      },
      {
         user:'COMMENT_BY',
         message: TEXT,
         dateCreated: DATE_TIME,
         like: LIKES
      }
   ]
}

इसलिए डेटा दिखाते समय, RDBMS में आपको तीन तालिकाओं में शामिल होने की आवश्यकता होती है और MongoDB में, डेटा केवल एक संग्रह से दिखाया जाएगा।

इस अध्याय में, हम देखेंगे कि MongoDB में एक डेटाबेस कैसे बनाया जाए।

उपयोग कमांड

MongoDB use DATABASE_NAMEडेटाबेस बनाने के लिए उपयोग किया जाता है। यदि यह मौजूद नहीं है, तो कमांड एक नया डेटाबेस बनाएगा, अन्यथा यह मौजूदा डेटाबेस को वापस कर देगा।

वाक्य - विन्यास

का मूल सिंटैक्स use DATABASE कथन इस प्रकार है -

use DATABASE_NAME

उदाहरण

यदि आप नाम के साथ डेटाबेस का उपयोग करना चाहते हैं <mydb>, फिर use DATABASE कथन इस प्रकार होगा -

>use mydb
switched to db mydb

अपने वर्तमान में चयनित डेटाबेस की जांच करने के लिए, कमांड का उपयोग करें db

>db
mydb

यदि आप अपनी डेटाबेस सूची की जाँच करना चाहते हैं, तो कमांड का उपयोग करें show dbs

>show dbs
local     0.78125GB
test      0.23012GB

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

>db.movie.insert({"name":"tutorials point"})
>show dbs
local      0.78125GB
mydb       0.23012GB
test       0.23012GB

में MongoDB डिफ़ॉल्ट डेटाबेस परीक्षण है। यदि आपने कोई डेटाबेस नहीं बनाया है, तो संग्रह परीक्षण डेटाबेस में संग्रहीत किया जाएगा।

इस अध्याय में, हम देखेंगे कि MongoDB कमांड का उपयोग करके डेटाबेस को कैसे छोड़ा जाए।

ड्रॉपडाटबेस () विधि

MongoDB db.dropDatabase() मौजूदा डेटाबेस को छोड़ने के लिए कमांड का उपयोग किया जाता है।

वाक्य - विन्यास

का मूल सिंटैक्स dropDatabase() कमांड इस प्रकार है -

db.dropDatabase()

यह चयनित डेटाबेस को हटा देगा। यदि आपने किसी डेटाबेस का चयन नहीं किया है, तो यह डिफ़ॉल्ट 'टेस्ट' डेटाबेस को हटा देगा।

उदाहरण

सबसे पहले, कमांड का उपयोग करके उपलब्ध डेटाबेस की सूची देखें। show dbs

>show dbs
local      0.78125GB
mydb       0.23012GB
test       0.23012GB
>

यदि आप नए डेटाबेस को हटाना चाहते हैं <mydb>, फिर dropDatabase() कमांड इस प्रकार होगी -

>use mydb
switched to db mydb
>db.dropDatabase()
>{ "dropped" : "mydb", "ok" : 1 }
>

अब डेटाबेस की सूची की जाँच करें।

>show dbs
local      0.78125GB
test       0.23012GB
>

इस अध्याय में, हम देखेंगे कि MongoDB का उपयोग करके एक संग्रह कैसे बनाया जाए।

CreateCollection () मेथड

MongoDB db.createCollection(name, options) का उपयोग संग्रह बनाने के लिए किया जाता है।

वाक्य - विन्यास

का मूल सिंटैक्स createCollection() कमांड इस प्रकार है -

db.createCollection(name, options)

कमांड में, name बनाने के लिए संग्रह का नाम है। Options एक दस्तावेज है और संग्रह के विन्यास को निर्दिष्ट करने के लिए उपयोग किया जाता है।

पैरामीटर प्रकार विवरण
नाम तार संग्रह का नाम
विकल्प डाक्यूमेंट (वैकल्पिक) मेमोरी आकार और अनुक्रमण के बारे में विकल्प निर्दिष्ट करें

विकल्प पैरामीटर वैकल्पिक है, इसलिए आपको केवल संग्रह का नाम निर्दिष्ट करने की आवश्यकता है। निम्नलिखित विकल्पों की सूची आप उपयोग कर सकते हैं -

मैदान प्रकार विवरण
छाया हुआ बूलियन (वैकल्पिक) यदि सत्य है, एक कैप्ड संग्रह को सक्षम करता है। कैप्ड संग्रह एक निश्चित आकार का संग्रह है जो अपने अधिकतम आकार तक पहुंचने पर स्वचालित रूप से अपनी सबसे पुरानी प्रविष्टियों को अधिलेखित कर देता है।If you specify true, you need to specify size parameter also.
autoIndexId बूलियन (वैकल्पिक) यदि सही है, तो स्वचालित रूप से _id फ़ील्ड पर इंडेक्स बनाएं। डिफ़ॉल्ट मान गलत है।
आकार संख्या (वैकल्पिक) कैप्ड संग्रह के लिए बाइट्स में अधिकतम आकार निर्दिष्ट करता है। If capped is true, then you need to specify this field also.
मैक्स संख्या (वैकल्पिक) कैप्ड संग्रह में अनुमत अधिकतम दस्तावेज़ों को निर्दिष्ट करता है।

दस्तावेज़ को सम्मिलित करते समय, MongoDB पहले कैप्ड संग्रह के आकार क्षेत्र की जांच करता है, फिर यह अधिकतम फ़ील्ड की जांच करता है।

उदाहरण

का मूल सिंटैक्स createCollection() विकल्प के बिना विधि इस प्रकार है -

>use test
switched to db test
>db.createCollection("mycollection")
{ "ok" : 1 }
>

आप कमांड का उपयोग करके बनाए गए संग्रह की जांच कर सकते हैं show collections

>show collections
mycollection
system.indexes

निम्नलिखित उदाहरण के सिंटैक्स को दर्शाता है createCollection() कुछ महत्वपूर्ण विकल्पों के साथ विधि -

>db.createCollection("mycol", { capped : true, autoIndexId : true, size : 
   6142800, max : 10000 } )
{ "ok" : 1 }
>

MongoDB में, आपको संग्रह बनाने की आवश्यकता नहीं है। जब आप कुछ दस्तावेज़ सम्मिलित करते हैं, तो MongoDB स्वचालित रूप से संग्रह बनाता है।

>db.tutorialspoint.insert({"name" : "tutorialspoint"})
>show collections
mycol
mycollection
system.indexes
tutorialspoint
>

इस अध्याय में, हम देखेंगे कि MongoDB का उपयोग करके एक संग्रह कैसे छोड़ा जाए।

ड्रॉप () विधि

MongoDB के db.collection.drop() डेटाबेस से एक संग्रह को छोड़ने के लिए उपयोग किया जाता है।

वाक्य - विन्यास

का मूल सिंटैक्स drop() कमांड इस प्रकार है -

db.COLLECTION_NAME.drop()

उदाहरण

सबसे पहले, अपने डेटाबेस में उपलब्ध संग्रहों की जाँच करें mydb

>use mydb
switched to db mydb
>show collections
mycol
mycollection
system.indexes
tutorialspoint
>

अब नाम के साथ संग्रह छोड़ दें mycollection

>db.mycollection.drop()
true
>

फिर से डेटाबेस में संग्रह की सूची की जाँच करें।

>show collections
mycol
system.indexes
tutorialspoint
>

ड्रॉप () विधि सही लौटेगी, यदि चयनित संग्रह सफलतापूर्वक गिरा दिया गया है, अन्यथा यह गलत वापस आ जाएगा।

MongoDB कई डेटाटिप्स का समर्थन करता है। उनमें से कुछ हैं -

  • String- डेटा को स्टोर करने के लिए यह सबसे अधिक उपयोग किया जाने वाला डेटाटाइप है। MongoDB में स्ट्रिंग UTF-8 मान्य होनी चाहिए।

  • Integer- इस प्रकार का उपयोग संख्यात्मक मान को संग्रहीत करने के लिए किया जाता है। पूर्णांक आपके सर्वर के आधार पर 32 बिट या 64 बिट हो सकता है।

  • Boolean - इस प्रकार का उपयोग बूलियन (सही / गलत) मान को संग्रहीत करने के लिए किया जाता है।

  • Double - इस प्रकार का उपयोग फ्लोटिंग पॉइंट वैल्यू को स्टोर करने के लिए किया जाता है।

  • Min/ Max keys - इस प्रकार का उपयोग सबसे कम और उच्चतम BSON तत्वों के खिलाफ एक मूल्य की तुलना करने के लिए किया जाता है।

  • Arrays - इस प्रकार का उपयोग सरणियों या सूची या कई मानों को एक कुंजी में संग्रहीत करने के लिए किया जाता है।

  • Timestamp- ctimestamp। यह रिकॉर्डिंग के लिए आसान हो सकता है जब कोई दस्तावेज़ संशोधित या जोड़ा गया हो।

  • Object - इस डेटाटाइप का उपयोग एम्बेडेड दस्तावेजों के लिए किया जाता है।

  • Null - इस प्रकार का उपयोग नल मान को संग्रहीत करने के लिए किया जाता है।

  • Symbol- इस डेटाटाइप का उपयोग पहचान के लिए स्ट्रिंग के लिए किया जाता है; हालाँकि, यह आम तौर पर उन भाषाओं के लिए आरक्षित होता है जो एक विशिष्ट प्रतीक प्रकार का उपयोग करते हैं।

  • Date - इस डेटाटाइप का उपयोग UNIX समय प्रारूप में वर्तमान दिनांक या समय को संग्रहीत करने के लिए किया जाता है। आप दिनांक की वस्तु बनाकर और उसमें दिन, माह, वर्ष का अपना दिनांक समय निर्दिष्ट कर सकते हैं।

  • Object ID - इस डेटाटाइप का इस्तेमाल डॉक्यूमेंट की आईडी को स्टोर करने के लिए किया जाता है।

  • Binary data - इस डेटाटाइप का उपयोग बाइनरी डेटा को स्टोर करने के लिए किया जाता है।

  • Code - इस डेटाटाइप का उपयोग डॉक्यूमेंट में जावास्क्रिप्ट कोड को स्टोर करने के लिए किया जाता है।

  • Regular expression - इस डेटाटाइप का इस्तेमाल रेगुलर एक्सप्रेशन को स्टोर करने के लिए किया जाता है।

इस अध्याय में, हम सीखेंगे कि MongoDB संग्रह में दस्तावेज़ कैसे डालें।

सम्मिलित () विधि

MongoDB संग्रह में डेटा सम्मिलित करने के लिए, आपको MongoDB का उपयोग करने की आवश्यकता है insert() या save() तरीका।

वाक्य - विन्यास

का मूल सिंटैक्स insert() कमांड इस प्रकार है -

>db.COLLECTION_NAME.insert(document)

उदाहरण

>db.mycol.insert({
   _id: ObjectId(7df78ad8902c),
   title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by: 'tutorials point',
   url: 'http://www.tutorialspoint.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100
})

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

सम्मिलित दस्तावेज़ में, यदि हम _id पैरामीटर निर्दिष्ट नहीं करते हैं, तो MongoDB इस दस्तावेज़ के लिए एक अद्वितीय ObjectId प्रदान करता है।

_id एक संग्रह में प्रत्येक दस्तावेज़ के लिए 12 बाइट्स हेक्साडेसिमल संख्या अद्वितीय है। 12 बाइट्स इस प्रकार विभाजित हैं -

_id: ObjectId(4 bytes timestamp, 3 bytes machine id, 2 bytes process id, 
   3 bytes incrementer)

एक ही क्वेरी में कई दस्तावेज़ सम्मिलित करने के लिए, आप सम्मिलित () कमांड में दस्तावेज़ों की एक सरणी पास कर सकते हैं।

उदाहरण

>db.post.insert([
   {
      title: 'MongoDB Overview', 
      description: 'MongoDB is no sql database',
      by: 'tutorials point',
      url: 'http://www.tutorialspoint.com',
      tags: ['mongodb', 'database', 'NoSQL'],
      likes: 100
   },
	
   {
      title: 'NoSQL Database', 
      description: "NoSQL database doesn't have tables",
      by: 'tutorials point',
      url: 'http://www.tutorialspoint.com',
      tags: ['mongodb', 'database', 'NoSQL'],
      likes: 20, 
      comments: [	
         {
            user:'user1',
            message: 'My first comment',
            dateCreated: new Date(2013,11,10,2,35),
            like: 0 
         }
      ]
   }
])

उस दस्तावेज़ को सम्मिलित करने के लिए जिसका आप उपयोग कर सकते हैं db.post.save(document)भी। यदि आप निर्दिष्ट नहीं करते हैं_id दस्तावेज़ में तब save() विधि उसी तरह काम करेगी insert()तरीका। यदि आप _id निर्दिष्ट करते हैं तो यह दस्तावेज़ के पूरे डेटा को प्रतिस्थापित करेगा जिसमें सेव () विधि में निर्दिष्ट है।

इस अध्याय में, हम सीखेंगे कि कैसे MongoDB संग्रह से दस्तावेज़ को क्वेरी करना है।

खोज () विधि

MongoDB संग्रह के डेटा को क्वेरी करने के लिए, आपको MongoDB का उपयोग करने की आवश्यकता है find() तरीका।

वाक्य - विन्यास

का मूल सिंटैक्स find() विधि इस प्रकार है -

>db.COLLECTION_NAME.find()

find() विधि सभी दस्तावेजों को गैर-संरचित तरीके से प्रदर्शित करेगी।

सुंदर () विधि

परिणामों को स्वरूपित तरीके से प्रदर्शित करने के लिए, आप उपयोग कर सकते हैं pretty() तरीका।

वाक्य - विन्यास

>db.mycol.find().pretty()

उदाहरण

>db.mycol.find().pretty()
{
   "_id": ObjectId(7df78ad8902c),
   "title": "MongoDB Overview", 
   "description": "MongoDB is no sql database",
   "by": "tutorials point",
   "url": "http://www.tutorialspoint.com",
   "tags": ["mongodb", "database", "NoSQL"],
   "likes": "100"
}
>

खोज () विधि के अलावा है findOne() विधि, वह केवल एक दस्तावेज़ लौटाता है।

RDBMS मानगोडीबी में क्लॉज इक्विलेवेंट्स कहां है

दस्तावेज़ को कुछ शर्त के आधार पर क्वेरी करने के लिए, आप निम्नलिखित कार्यों का उपयोग कर सकते हैं।

ऑपरेशन वाक्य - विन्यास उदाहरण RDBMS समतुल्य
समानता {<कुंजी>: <मूल्य>} db.mycol.find ({"by": "ट्यूटोरियल्स पॉइंट"})। सुंदर () कहाँ = 'ट्यूटोरियल पॉइंट' द्वारा
से कम {<कुंजी>: {$ lt: <मूल्य>}} db.mycol.find ({ "पसंद": {$ lt: 50}})। सुंदर () जहां पसंद है <50
बराबरी से कम {<कुंजी>: {$ एलटीई: <मूल्य>}} db.mycol.find ({ "पसंद": {$ एलटीई: 50}})। सुंदर () जहाँ पसंद है <= 50
से अधिक {<कुंजी>: {$ जीटी: <मूल्य>}} db.mycol.find ({ "पसंद": {$ जीटी: 50}})। सुंदर () जहां पसंद> 50
ग्रेटर थान बराबर {<कुंजी>: {$ gte: <मूल्य>}} db.mycol.find ({ "पसंद": {$ gte: 50}})। सुंदर () जहाँ पसंद है = = ५०
न के बराबर {<कुंजी>: {$ ne: <मूल्य>}} db.mycol.find ({ "पसंद": {$ ne: 50}})। सुंदर () जहां पसंद है! = 50

और MongoDB में

वाक्य - विन्यास

में find() विधि, यदि आप कई कुंजियों को 'द्वारा अलग करके' पास करते हैं, तो MongoDB इसे मानता है ANDस्थिति। निम्नलिखित का मूल सिंटैक्स हैAND -

>db.mycol.find(
   {
      $and: [
         {key1: value1}, {key2:value2}
      ]
   }
).pretty()

उदाहरण

उदाहरण के बाद 'ट्यूटोरियल पॉइंट' द्वारा लिखे गए सभी ट्यूटोरियल दिखाएंगे और जिसका शीर्षक 'MongoDB ओवरव्यू' होगा।

>db.mycol.find({$and:[{"by":"tutorials point"},{"title": "MongoDB Overview"}]}).pretty() {
   "_id": ObjectId(7df78ad8902c),
   "title": "MongoDB Overview", 
   "description": "MongoDB is no sql database",
   "by": "tutorials point",
   "url": "http://www.tutorialspoint.com",
   "tags": ["mongodb", "database", "NoSQL"],
   "likes": "100"
}

ऊपर दिए गए उदाहरण के लिए, समतुल्य जहां खंड होगा ' where by = 'tutorials point' AND title = 'MongoDB Overview' '। आप खोज खंड में किसी भी संख्या में कुंजी, मान जोड़े पास कर सकते हैं।

या मोंगोडीबी में

वाक्य - विन्यास

OR शर्त के आधार पर दस्तावेजों को क्वेरी करने के लिए, आपको उपयोग करने की आवश्यकता है $orकीवर्ड। निम्नलिखित का मूल सिंटैक्स हैOR -

>db.mycol.find(
   {
      $or: [
         {key1: value1}, {key2:value2}
      ]
   }
).pretty()

उदाहरण

उदाहरण के बाद 'ट्यूटोरियल्स पॉइंट' द्वारा लिखे गए सभी ट्यूटोरियल दिखाए जाएँगे या जिनका शीर्षक 'MongoDB ओवरव्यू' होगा।

>db.mycol.find({$or:[{"by":"tutorials point"},{"title": "MongoDB Overview"}]}).pretty()
{
   "_id": ObjectId(7df78ad8902c),
   "title": "MongoDB Overview", 
   "description": "MongoDB is no sql database",
   "by": "tutorials point",
   "url": "http://www.tutorialspoint.com",
   "tags": ["mongodb", "database", "NoSQL"],
   "likes": "100"
}
>

AND और OR का एक साथ उपयोग करना

उदाहरण

निम्न उदाहरण उन दस्तावेजों को दिखाएगा जो 10 से अधिक पसंद करते हैं और जिसका शीर्षक या तो 'MongoDB अवलोकन' है या 'ट्यूटोरियल पॉइंट' है। समतुल्य एसक्यूएल जहाँ खण्ड है'where likes>10 AND (by = 'tutorials point' OR title = 'MongoDB Overview')'

>db.mycol.find({"likes": {$gt:10}, $or: [{"by": "tutorials point"},
   {"title": "MongoDB Overview"}]}).pretty()
{
   "_id": ObjectId(7df78ad8902c),
   "title": "MongoDB Overview", 
   "description": "MongoDB is no sql database",
   "by": "tutorials point",
   "url": "http://www.tutorialspoint.com",
   "tags": ["mongodb", "database", "NoSQL"],
   "likes": "100"
}
>

MongoDB के update() तथा save()किसी संग्रह में दस्तावेज़ को अद्यतन करने के लिए विधियों का उपयोग किया जाता है। अद्यतन () विधि मौजूदा दस्तावेज़ में मूल्यों को अपडेट करती है जबकि सहेजें () विधि मौजूदा दस्तावेज़ को सहेजने () विधि में पारित दस्तावेज़ के साथ बदल देती है।

MongoDB अपडेट () विधि

अद्यतन () विधि मौजूदा दस्तावेज़ में मूल्यों को अपडेट करती है।

वाक्य - विन्यास

का मूल सिंटैक्स update() विधि इस प्रकार है -

>db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATA)

उदाहरण

विचार करें कि mycol संग्रह में निम्नलिखित डेटा है।

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

निम्नलिखित उदाहरण दस्तावेजों का नया शीर्षक 'नया MongoDB ट्यूटोरियल' सेट करेगा जिसका शीर्षक 'MongoDB अवलोकन' है।

>db.mycol.update({'title':'MongoDB Overview'},{$set:{'title':'New MongoDB Tutorial'}})
>db.mycol.find()
{ "_id" : ObjectId(5983548781331adf45ec5), "title":"New MongoDB Tutorial"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}
>

डिफ़ॉल्ट रूप से, MongoDB केवल एक दस्तावेज़ को अपडेट करेगा। कई दस्तावेजों को अपडेट करने के लिए, आपको एक पैरामीटर 'मल्टी' को सही पर सेट करना होगा।

>db.mycol.update({'title':'MongoDB Overview'},
   {$set:{'title':'New MongoDB Tutorial'}},{multi:true})

MongoDB सहेजें () विधि

save() विधि मौजूदा दस्तावेज़ को सहेजने () पद्धति में नए दस्तावेज़ के साथ बदल देती है।

वाक्य - विन्यास

MongoDB का मूल सिंटैक्स save() विधि नीचे दी गई है -

>db.COLLECTION_NAME.save({_id:ObjectId(),NEW_DATA})

उदाहरण

निम्नलिखित उदाहरण दस्तावेज़ को _id '5983548781331adf45ec5' से बदल देगा।

>db.mycol.save(
   {
      "_id" : ObjectId(5983548781331adf45ec5), "title":"Tutorials Point New Topic",
      "by":"Tutorials Point"
   }
)
>db.mycol.find()
{ "_id" : ObjectId(5983548781331adf45ec5), "title":"Tutorials Point New Topic",
   "by":"Tutorials Point"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}
>

इस अध्याय में, हम सीखेंगे कि MongoDB का उपयोग करके किसी दस्तावेज़ को कैसे हटाया जाए।

हटाने () विधि

MongoDB के remove()संग्रह से दस्तावेज़ को निकालने के लिए विधि का उपयोग किया जाता है। निकालें () विधि दो मापदंडों को स्वीकार करती है। एक विलोपन मानदंड है और दूसरा जस्टऑन फ्लैग है।

  • deletion criteria - (वैकल्पिक) दस्तावेजों के अनुसार विलोपन मानदंड हटा दिया जाएगा।

  • justOne - (वैकल्पिक) यदि सही या 1 पर सेट है, तो केवल एक दस्तावेज़ निकालें।

वाक्य - विन्यास

का मूल सिंटैक्स remove() विधि इस प्रकार है -

>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)

उदाहरण

विचार करें कि mycol संग्रह में निम्नलिखित डेटा है।

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

उदाहरण के बाद उन सभी दस्तावेजों को हटा दिया जाएगा, जिनका शीर्षक 'MongoDB अवलोकन' है।

>db.mycol.remove({'title':'MongoDB Overview'})
>db.mycol.find()
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}
>

केवल एक निकालें

यदि कई रिकॉर्ड हैं और आप केवल पहले रिकॉर्ड को हटाना चाहते हैं, तो सेट करें justOne में पैरामीटर remove() तरीका।

>db.COLLECTION_NAME.remove(DELETION_CRITERIA,1)

सभी दस्तावेज़ निकालें

यदि आप विलोपन मानदंड निर्दिष्ट नहीं करते हैं, तो MongoDB संग्रह से पूरे दस्तावेज़ हटा देगा। This is equivalent of SQL's truncate command.

>db.mycol.remove({})
>db.mycol.find()
>

MongoDB में, प्रक्षेपण का अर्थ है किसी दस्तावेज़ के संपूर्ण डेटा का चयन करने के बजाय केवल आवश्यक डेटा का चयन करना। यदि किसी दस्तावेज़ में 5 फ़ील्ड हैं और आपको केवल 3 दिखाने की आवश्यकता है, तो उनमें से केवल 3 फ़ील्ड चुनें।

खोज () विधि

MongoDB के find()MongoDB क्वेरी दस्तावेज़ में बताई गई विधि, दूसरे वैकल्पिक पैरामीटर को स्वीकार करती है जो उन क्षेत्रों की सूची है जिन्हें आप पुनः प्राप्त करना चाहते हैं। MongoDB में, जब आप निष्पादित करते हैंfind()विधि, फिर यह एक दस्तावेज़ के सभी क्षेत्रों को प्रदर्शित करता है। इसे सीमित करने के लिए, आपको फ़ील्ड की एक सूची सेट करने की आवश्यकता है जिसका मान 1 या 0. है 1 का उपयोग फ़ील्ड को दिखाने के लिए किया जाता है जबकि 0 का उपयोग फ़ील्ड को छिपाने के लिए किया जाता है।

वाक्य - विन्यास

का मूल सिंटैक्स find() प्रक्षेपण की विधि इस प्रकार है -

>db.COLLECTION_NAME.find({},{KEY:1})

उदाहरण

संग्रह पर विचार करें mycol में निम्नलिखित डेटा है -

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

उदाहरण के बाद दस्तावेज़ को उद्धृत करते हुए दस्तावेज़ का शीर्षक प्रदर्शित करेगा।

>db.mycol.find({},{"title":1,_id:0})
{"title":"MongoDB Overview"}
{"title":"NoSQL Overview"}
{"title":"Tutorials Point Overview"}
>

कृपया ध्यान दें _id फ़ील्ड को हमेशा निष्पादित करते समय प्रदर्शित किया जाता है find() विधि, यदि आप इस क्षेत्र को नहीं चाहते हैं, तो आपको इसे 0 के रूप में सेट करने की आवश्यकता है।

इस अध्याय में, हम सीखेंगे कि MongoDB का उपयोग करके रिकॉर्ड कैसे सीमित करें।

सीमा () विधि

MongoDB में रिकॉर्ड को सीमित करने के लिए, आपको उपयोग करने की आवश्यकता है limit()तरीका। विधि एक नंबर प्रकार के तर्क को स्वीकार करती है, जो आपके द्वारा प्रदर्शित किए जाने वाले दस्तावेज़ों की संख्या है।

वाक्य - विन्यास

का मूल सिंटैक्स limit() विधि इस प्रकार है -

>db.COLLECTION_NAME.find().limit(NUMBER)

उदाहरण

संग्रह पर विचार करें माइकोल में निम्नलिखित डेटा है।

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

उदाहरण के बाद दस्तावेज़ को क्वेरी करते समय केवल दो दस्तावेज़ प्रदर्शित होंगे।

>db.mycol.find({},{"title":1,_id:0}).limit(2)
{"title":"MongoDB Overview"}
{"title":"NoSQL Overview"}
>

यदि आप संख्या तर्क निर्दिष्ट नहीं करते हैं limit() विधि तब यह संग्रह से सभी दस्तावेजों को प्रदर्शित करेगा।

MongoDB स्किप () विधि

सीमा () विधि के अलावा, एक और विधि है skip() जो संख्या प्रकार तर्क को भी स्वीकार करता है और दस्तावेजों की संख्या को छोड़ने के लिए उपयोग किया जाता है।

वाक्य - विन्यास

का मूल सिंटैक्स skip() विधि इस प्रकार है -

>db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)

उदाहरण

निम्न उदाहरण केवल दूसरा दस्तावेज़ प्रदर्शित करेगा।

>db.mycol.find({},{"title":1,_id:0}).limit(1).skip(1)
{"title":"NoSQL Overview"}
>

कृपया ध्यान दें, डिफ़ॉल्ट मान skip() विधि 0 है।

इस अध्याय में, हम सीखेंगे कि MongoDB में रिकॉर्ड कैसे छांटें।

क्रमबद्ध () विधि

MongoDB में दस्तावेज़ों को सॉर्ट करने के लिए, आपको उपयोग करने की आवश्यकता है sort()तरीका। विधि उन दस्तावेज़ों को स्वीकार करती है जिनमें उनके क्रमबद्ध क्रम के साथ फ़ील्ड्स की एक सूची होती है। सॉर्टिंग ऑर्डर को निर्दिष्ट करने के लिए 1 और -1 का उपयोग किया जाता है। 1 का उपयोग आरोही क्रम के लिए किया जाता है जबकि -1 का उपयोग अवरोही क्रम के लिए किया जाता है।

वाक्य - विन्यास

का मूल सिंटैक्स sort() विधि इस प्रकार है -

>db.COLLECTION_NAME.find().sort({KEY:1})

उदाहरण

संग्रह पर विचार करें माइकोल में निम्नलिखित डेटा है।

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

निम्न उदाहरण अवरोही क्रम में शीर्षक द्वारा छांटे गए दस्तावेजों को प्रदर्शित करेगा।

>db.mycol.find({},{"title":1,_id:0}).sort({"title":-1})
{"title":"Tutorials Point Overview"}
{"title":"NoSQL Overview"}
{"title":"MongoDB Overview"}
>

कृपया ध्यान दें, यदि आप छँटाई वरीयता को निर्दिष्ट नहीं करते हैं, तो sort() विधि दस्तावेजों को आरोही क्रम में प्रदर्शित करेगी।

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

इंडेक्स विशेष डेटा संरचनाएं हैं, जो डेटा के एक छोटे हिस्से को एक आसान-से-ट्रैवर्स फॉर्म में संग्रहीत करती हैं। सूचकांक सूचकांक में निर्दिष्ट क्षेत्र के मूल्य के अनुसार एक विशिष्ट फ़ील्ड या फ़ील्ड्स के सेट का मूल्य संग्रहीत करता है।

EnsIndex () विधि

एक इंडेक्स बनाने के लिए आपको MongoDB का सुनिश्‍चित करें।

वाक्य - विन्यास

का मूल सिंटैक्स ensureIndex() विधि इस प्रकार है ()।

>db.COLLECTION_NAME.ensureIndex({KEY:1})

यहां कुंजी उस फ़ील्ड का नाम है, जिस पर आप इंडेक्स बनाना चाहते हैं और 1 आरोही क्रम के लिए है। अवरोही क्रम में सूचकांक बनाने के लिए आपको -1 का उपयोग करने की आवश्यकता है।

उदाहरण

>db.mycol.ensureIndex({"title":1})
>

में ensureIndex() विधि आप कई क्षेत्रों को पार कर सकते हैं, कई क्षेत्रों पर सूचकांक बनाने के लिए।

>db.mycol.ensureIndex({"title":1,"description":-1})
>

ensureIndex()विधि विकल्पों की सूची भी स्वीकार करती है (जो वैकल्पिक हैं)। निम्नलिखित सूची है -

पैरामीटर प्रकार विवरण
पृष्ठभूमि बूलियन इंडेक्स को पृष्ठभूमि में बनाता है ताकि एक इंडेक्स का निर्माण अन्य डेटाबेस गतिविधियों को अवरुद्ध न करें। पृष्ठभूमि में बनाने के लिए सही निर्दिष्ट करें। डिफ़ॉल्ट मान हैfalse
अद्वितीय बूलियन एक अद्वितीय सूचकांक बनाता है ताकि संग्रह दस्तावेजों के सम्मिलन को स्वीकार नहीं करेगा जहां सूचकांक कुंजी या चाबियाँ सूचकांक में मौजूदा मूल्य से मेल खाती हैं। एक अद्वितीय सूचकांक बनाने के लिए सही निर्दिष्ट करें। डिफ़ॉल्ट मान हैfalse
नाम तार सूचकांक का नाम। यदि अनिर्दिष्ट है, तो MongoDB अनुक्रमित फ़ील्ड और सॉर्ट क्रम के नामों को संक्षिप्त करके एक इंडेक्स नाम बनाता है।
dropDups बूलियन एक क्षेत्र पर एक अद्वितीय सूचकांक बनाता है जिसमें डुप्लिकेट हो सकते हैं। MongoDB एक कुंजी की केवल पहली घटना को अनुक्रमित करता है और संग्रह से सभी दस्तावेजों को हटाता है जिसमें उस कुंजी की बाद की घटनाएं होती हैं। अद्वितीय सूचकांक बनाने के लिए सही निर्दिष्ट करें। डिफ़ॉल्ट मान हैfalse
विरल बूलियन यदि सही है, तो सूचकांक केवल निर्दिष्ट क्षेत्र के साथ दस्तावेजों का संदर्भ देता है। ये सूचकांक कम जगह का उपयोग करते हैं लेकिन कुछ स्थितियों (विशेष रूप से प्रकार) में अलग तरह से व्यवहार करते हैं। डिफ़ॉल्ट मान हैfalse
expireAfterSeconds पूर्णांक इस संग्रह में दस्तावेज़ों को लंबे समय तक बनाए रखने के लिए TTL के रूप में सेकंड में एक मान निर्दिष्ट करता है।
v सूचकांक संस्करण सूचकांक संस्करण संख्या। इंडेक्स बनाते समय डिफॉल्ट इंडेक्स वर्जन MongoDB के वर्जन पर निर्भर करता है।
तौल डाक्यूमेंट वजन 1 से 99,999 तक की संख्या है और स्कोर के संदर्भ में अन्य अनुक्रमित क्षेत्रों के सापेक्ष क्षेत्र के महत्व को दर्शाता है।
डिफ़ॉल्ट भाषा तार एक टेक्स्ट इंडेक्स के लिए, वह भाषा जो स्टॉप शब्दों की सूची और स्टेमर और टोकन के लिए नियम निर्धारित करती है। डिफ़ॉल्ट मान हैenglish
language_override तार टेक्स्ट इंडेक्स के लिए, दस्तावेज़ में फ़ील्ड का नाम निर्दिष्ट करें, जिसमें डिफ़ॉल्ट भाषा को ओवरराइड करने की भाषा है। डिफ़ॉल्ट मान भाषा है।

एकत्रीकरण संचालन डेटा रिकॉर्ड की प्रक्रिया करता है और गणना किए गए परिणाम लौटाता है। एक साथ कई दस्तावेजों से एकत्रीकरण संचालन समूह मान, और एकल परिणाम वापस करने के लिए समूहीकृत डेटा पर कई प्रकार के संचालन कर सकते हैं। SQL काउंट (*) में और समूह के साथ mongodb एकत्रीकरण के बराबर है।

कुल () विधि

MongoDB में एकत्रीकरण के लिए, आपको उपयोग करना चाहिए aggregate() तरीका।

वाक्य - विन्यास

का मूल सिंटैक्स aggregate() विधि इस प्रकार है -

>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

उदाहरण

संग्रह में आपके पास निम्नलिखित डेटा हैं -

{
   _id: ObjectId(7df78ad8902c)
   title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by_user: 'tutorials point',
   url: 'http://www.tutorialspoint.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100
},
{
   _id: ObjectId(7df78ad8902d)
   title: 'NoSQL Overview', 
   description: 'No sql database is very fast',
   by_user: 'tutorials point',
   url: 'http://www.tutorialspoint.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 10
},
{
   _id: ObjectId(7df78ad8902e)
   title: 'Neo4j Overview', 
   description: 'Neo4j is no sql database',
   by_user: 'Neo4j',
   url: 'http://www.neo4j.com',
   tags: ['neo4j', 'database', 'NoSQL'],
   likes: 750
},

अब उपरोक्त संग्रह से, यदि आप एक सूची दिखाना चाहते हैं कि प्रत्येक उपयोगकर्ता द्वारा कितने ट्यूटोरियल लिखे गए हैं, तो आप निम्नलिखित का उपयोग करेंगे aggregate() विधि -

> db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])
{
   "result" : [
      {
         "_id" : "tutorials point",
         "num_tutorial" : 2
      },
      {
         "_id" : "Neo4j",
         "num_tutorial" : 1
      }
   ],
   "ok" : 1
}
>

उपरोक्त उपयोग के मामले के लिए Sql समकक्ष क्वेरी होगी select by_user, count(*) from mycol group by by_user

उपरोक्त उदाहरण में, हमने फ़ील्ड द्वारा दस्तावेज़ों को समूहीकृत किया है by_userऔर बी_सियर की प्रत्येक घटना पर पिछले मूल्य का योग बढ़ जाता है। निम्नलिखित एकत्रीकरण अभिव्यक्तियों की एक सूची है।

अभिव्यक्ति विवरण उदाहरण
$ योग संग्रह में सभी दस्तावेजों से परिभाषित मूल्य तय करता है। db.mycol.aggregate ([{$ समूह: {_id: "$by_user", num_tutorial : {$योग: "$ पसंद"}}}])
$ औसत संग्रह में सभी दस्तावेजों से दिए गए सभी मूल्यों के औसत की गणना करता है। db.mycol.aggregate ([{$group : {_id : "$by_user ", num_tutorial: {$avg : "$को यह पसंद है"}}}])
$ मिनट संग्रह में सभी दस्तावेजों से संबंधित मूल्यों के न्यूनतम हो जाता है। db.mycol.aggregate ([{$ समूह: {_id: "$by_user", num_tutorial : {$मिनट: "$ पसंद"}}}])
$ अधिकतम संग्रह में सभी दस्तावेजों से संबंधित मूल्यों की अधिकतम हो जाता है। db.mycol.aggregate ([{$group : {_id : "$by_user ", num_tutorial: {$max : "$को यह पसंद है"}}}])
$ धक्का परिणामी दस्तावेज़ में किसी सरणी में मान सम्मिलित करता है। db.mycol.aggregate ([{$ समूह: {_id: "$by_user", url : {$धक्का: "$ url"}}}])
$ addToSet परिणामी दस्तावेज़ में किसी सरणी में मान सम्मिलित करता है लेकिन डुप्लिकेट नहीं बनाता है। db.mycol.aggregate ([{$group : {_id : "$by_user ", url: {$addToSet : "$यूआरएल "}}}])
पहले $ समूहीकरण के अनुसार स्रोत दस्तावेज़ से पहला दस्तावेज़ प्राप्त करता है। आमतौर पर यह केवल पहले से लागू "$ सॉर्ट" -स्टेज के साथ मिलकर समझ में आता है। db.mycol.aggregate ([{$group : {_id : "$by_user ", first_url: {$first : "$यूआरएल "}}}])
$ पिछले समूहीकरण के अनुसार स्रोत दस्तावेज़ से अंतिम दस्तावेज़ प्राप्त करता है। आमतौर पर यह केवल पहले से लागू "$ सॉर्ट" -स्टेज के साथ मिलकर समझ में आता है। db.mycol.aggregate ([{$group : {_id : "$by_user ", last_url: {$last : "$यूआरएल "}}}])

पाइपलाइन की अवधारणा

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

एकत्रीकरण ढांचे में संभावित चरण निम्नलिखित हैं -

  • $project - एक संग्रह से कुछ विशिष्ट क्षेत्रों का चयन करने के लिए उपयोग किया जाता है।

  • $match - यह एक फ़िल्टरिंग ऑपरेशन है और इस प्रकार यह उन दस्तावेजों की मात्रा को कम कर सकता है जिन्हें अगले चरण में इनपुट के रूप में दिया गया है।

  • $group - यह वास्तविक एकत्रीकरण करता है जैसा कि ऊपर चर्चा की गई है।

  • $sort - दस्तावेज़ों को सॉर्ट करता है।

  • $skip - इसके साथ, दस्तावेजों की दी गई राशि के लिए दस्तावेजों की सूची में आगे छोड़ना संभव है।

  • $limit - यह मौजूदा पदों से शुरू की गई संख्या द्वारा दस्तावेजों को देखने की मात्रा को सीमित करता है।

  • $unwind- यह उन दस्तावेज़ों को खोलने के लिए उपयोग किया जाता है जो सरणियों का उपयोग कर रहे हैं। किसी सरणी का उपयोग करते समय, डेटा एक तरह से पूर्व में शामिल हो जाता है और इस ऑपरेशन को फिर से व्यक्तिगत दस्तावेजों के साथ पूर्ववत किया जाएगा। इस प्रकार इस चरण के साथ हम अगले चरण के लिए दस्तावेजों की मात्रा में वृद्धि करेंगे।

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

प्रतिकृति क्यों?

  • अपने डेटा को सुरक्षित रखने के लिए
  • डेटा की उच्च (24 * 7) उपलब्धता
  • आपदा बहाली
  • रखरखाव के लिए कोई डाउनटाइम (जैसे बैकअप, इंडेक्स रीबर्ड्स, संघनन)
  • स्केलिंग पढ़ें (अतिरिक्त प्रतियां पढ़ने के लिए)
  • प्रतिकृति सेट आवेदन के लिए पारदर्शी है

MongoDB में प्रतिकृति कैसे काम करती है

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

  • प्रतिकृति सेट दो या अधिक नोड्स का एक समूह है (आमतौर पर न्यूनतम 3 नोड्स की आवश्यकता होती है)।

  • एक प्रतिकृति सेट में, एक नोड प्राथमिक नोड है और शेष नोड माध्यमिक हैं।

  • सभी डेटा प्राथमिक से माध्यमिक नोड तक दोहराते हैं।

  • स्वचालित विफलता या रखरखाव के समय, प्राथमिक के लिए चुनाव स्थापित होता है और एक नया प्राथमिक नोड चुना जाता है।

  • असफल नोड की वसूली के बाद, यह फिर से प्रतिकृति सेट में शामिल होता है और द्वितीयक नोड के रूप में काम करता है।

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

प्रतिकृति सेट सुविधाएँ

  • एन नोड्स का एक समूह
  • कोई भी एक नोड प्राथमिक हो सकता है
  • सभी लेखन कार्य प्राथमिक जाते हैं
  • स्वचालित विफलता
  • स्वचालित वसूली
  • प्राथमिक का आम सहमति चुनाव

एक प्रतिकृति सेट करें

इस ट्यूटोरियल में, हम स्टैंडअलोन MongoDB उदाहरण को एक प्रतिकृति सेट में परिवर्तित करेंगे। प्रतिकृति सेट में बदलने के लिए, निम्नलिखित चरण हैं -

  • शटडाउन पहले से ही MongoDB सर्वर चला रहा है।

  • MongoDB सर्वर को निर्दिष्ट करके शुरू करें - प्रतिकृति विकल्प। निम्नलिखित --replSet का मूल सिंटैक्स है -

mongod --port "PORT" --dbpath "YOUR_DB_DATA_PATH" --replSet "REPLICA_SET_INSTANCE_NAME"

उदाहरण

mongod --port 27017 --dbpath "D:\set up\mongodb\data" --replSet rs0
  • यह 27017 पोर्ट पर rs0 नाम से एक मोंगॉड इंस्टेंस शुरू करेगा।

  • अब कमांड प्रॉम्प्ट शुरू करें और इस मोंगॉड इंस्टेंस से कनेक्ट करें।

  • Mongo क्लाइंट में, कमांड जारी करें rs.initiate() एक नया प्रतिकृति सेट आरंभ करने के लिए।

  • प्रतिकृति सेट कॉन्फ़िगरेशन की जाँच करने के लिए, कमांड जारी करें rs.conf()। प्रतिकृति सेट की स्थिति की जांच करने के लिए कमांड जारी करेंrs.status()

सदस्यों को प्रतिकृति सेट में जोड़ें

सदस्यों को प्रतिकृति सेट में जोड़ने के लिए, कई मशीनों पर मोंगॉड इंस्टेंस शुरू करें। अब एक मोंगो क्लाइंट शुरू करें और एक कमांड जारी करेंrs.add()

वाक्य - विन्यास

का मूल सिंटैक्स rs.add() कमांड इस प्रकार है -

>rs.add(HOST_NAME:PORT)

उदाहरण

मान लीजिए कि आपका मोंगॉड इंस्टेंस नाम है mongod1.net और यह बंदरगाह पर चल रहा है 27017। इस उदाहरण को प्रतिकृति सेट में जोड़ने के लिए, कमांड जारी करेंrs.add() मानगो ग्राहक में।

>rs.add("mongod1.net:27017")
>

आप केवल प्राथमिक नोड से जुड़े होने पर प्रतिकृति सेट में मोंगॉड उदाहरण जोड़ सकते हैं। यह जांचने के लिए कि आप प्राथमिक से जुड़े हैं या नहीं, कमांड जारी करेंdb.isMaster() ग्राहक में

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

शेयरिंग क्यों?

  • प्रतिकृति में, सभी लिखते हैं मास्टर नोड
  • लेटेंसी सेंसिटिव क्वेश्चन अभी भी मास्टर के पास जाते हैं
  • एकल प्रतिकृति सेट में 12 नोड्स की सीमा होती है
  • जब सक्रिय डेटासेट बड़ा होता है तो मेमोरी काफी बड़ी नहीं हो सकती है
  • स्थानीय डिस्क पर्याप्त बड़ी नहीं है
  • वर्टिकल स्केलिंग बहुत महंगी है

MongoDB में साझा करना

निम्नलिखित आरेख शेंगोल्ड क्लस्टर का उपयोग करते हुए MongoDB में पैनापन दिखाता है।

निम्नलिखित चित्र में, तीन मुख्य घटक हैं -

  • Shards- डेटा स्टोर करने के लिए Shards का उपयोग किया जाता है। वे उच्च उपलब्धता और डेटा स्थिरता प्रदान करते हैं। उत्पादन वातावरण में, प्रत्येक शार्क एक अलग प्रतिकृति सेट है।

  • Config Servers- कॉन्फ़िगरेशन सर्वर क्लस्टर के मेटाडेटा को संग्रहीत करते हैं। इस डेटा में क्लस्टर के डेटा को मैप्स पर मैप करना शामिल है। क्वेरी राउटर इस मेटाडाटा का उपयोग परिचालन को विशिष्ट शार्क को लक्षित करने के लिए करता है। उत्पादन परिवेश में, शार्प्ड क्लस्टर्स में बिल्कुल 3 कॉन्फिग सर्वर होते हैं।

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

इस अध्याय में, हम देखेंगे कि MongoDB में बैकअप कैसे बनाया जाता है।

डंप MongoDB डेटा

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

वाक्य - विन्यास

का मूल सिंटैक्स mongodump कमांड इस प्रकार है -

>mongodump

उदाहरण

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

विचार करें कि mycol संग्रह में निम्नलिखित डेटा है।

>mongodump

कमांड पर चल रहे सर्वर से कनेक्ट होगा 127.0.0.1 और बंदरगाह 27017 और निर्देशिका के लिए सर्वर के सभी डेटा वापस /bin/dump/। निम्नलिखित कमांड का उत्पादन है -

निम्नलिखित उपलब्ध विकल्पों की एक सूची है जिसका उपयोग इसके साथ किया जा सकता है mongodump आदेश।

वाक्य - विन्यास विवरण उदाहरण
mongodump --host HOST_NAME --पोर्ट PORT_NUMBER यह कमोड निर्दिष्ट मोंगॉड उदाहरण के सभी डेटाबेस का बैकअप लेगा। mongodump --host tutorialspoint.com --पोर्ट 27017
mongodump - dbpath DB_PATH - BACKUP_DIRECTORY यह कमांड निर्दिष्ट पथ पर केवल निर्दिष्ट डेटाबेस का बैकअप लेगा। mongodump - dbpath / data / db / --out / data / backup /
mongodump - रंग संकलन - db DB_NAME यह कमांड निर्दिष्ट डेटाबेस के केवल निर्दिष्ट संग्रह का बैकअप लेगा। mongodump - कोलियेशन mycol --db test

डेटा पुनः स्थापित करें

बैकअप डेटा को पुनर्स्थापित करने के लिए MongoDB है mongorestoreकमांड का उपयोग किया जाता है। यह निर्देश बैकअप निर्देशिका से सभी डेटा को पुनर्स्थापित करता है।

वाक्य - विन्यास

का मूल सिंटैक्स mongorestore कमांड है -

>mongorestore

निम्नलिखित कमांड का उत्पादन है -

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

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

अपनी तैनाती की निगरानी करने के लिए, MongoDB निम्नलिखित कुछ आदेश प्रदान करता है -

mongostat

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

कमांड चलाने के लिए, अपने मोंगॉड इंस्टेंस को शुरू करें। एक और कमांड प्रॉम्प्ट में, पर जाएंbin आपके मोंगॉडब इंस्टॉलेशन की निर्देशिका और प्रकार mongostat

D:\set up\mongodb\bin>mongostat

निम्नलिखित कमांड का उत्पादन है -

mongotop

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

कमांड चलाने के लिए, अपने मोंगॉड इंस्टेंस को शुरू करें। एक और कमांड प्रॉम्प्ट में, पर जाएंbin आपके मोंगॉडब इंस्टॉलेशन की निर्देशिका और प्रकार mongotop

D:\set up\mongodb\bin>mongotop

निम्नलिखित कमांड का उत्पादन है -

बदलने के लिए mongotop सूचना को कम बार वापस करने के लिए कमांड दें, मोंगोटो कमांड के बाद एक विशिष्ट संख्या निर्दिष्ट करें।

D:\set up\mongodb\bin>mongotop 30

उपरोक्त उदाहरण हर 30 सेकंड में मान लौटाएगा।

MongoDB टूल के अलावा, 10gen एक मुफ्त, होस्टेड मॉनिटरिंग सर्विस, MongoDB मैनेजमेंट सर्विस (MMS) प्रदान करता है, जो एक डैशबोर्ड प्रदान करता है और आपको अपने पूरे क्लस्टर से मेट्रिक्स का एक दृश्य प्रदान करता है।

इस अध्याय में, हम सीखेंगे कि MongoDB JDBC ड्राइवर कैसे सेट करें।

इंस्टालेशन

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

  • आपको जार को पथ से डाउनलोड करने की आवश्यकता है mongo.jar डाउनलोड करें । इसके नवीनतम रिलीज को डाउनलोड करना सुनिश्चित करें।

  • आपको अपने classpath में mongo.jar को शामिल करना होगा।

डेटाबेस से कनेक्ट करें

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

डेटाबेस से जुड़ने के लिए कोड स्निपेट निम्नलिखित है -

import com.mongodb.client.MongoDatabase; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class ConnectToDB { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 
   
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 
      System.out.println("Credentials ::"+ credential);     
   } 
}

अब, हमारे डेटाबेस myDb बनाने के लिए उपरोक्त प्रोग्राम को संकलित करें और चलाएं जैसा कि नीचे दिखाया गया है।

$javac ConnectToDB.java 
$java ConnectToDB

निष्पादित करने पर, उपरोक्त कार्यक्रम आपको निम्न आउटपुट देता है।

Connected to the database successfully 
Credentials ::MongoCredential{
   mechanism = null, 
   userName = 'sampleUser', 
   source = 'myDb', 
   password = <hidden>, 
   mechanismProperties = {}
}

एक संग्रह बनाएँ

एक संग्रह बनाने के लिए, createCollection() उसकि विधि com.mongodb.client.MongoDatabase वर्ग का उपयोग किया जाता है।

निम्नलिखित एक संग्रह बनाने के लिए कोड स्निपेट है -

import com.mongodb.client.MongoDatabase; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class CreatingCollection { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 
     
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      //Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb");  
      
      //Creating a collection 
      database.createCollection("sampleCollection"); 
      System.out.println("Collection created successfully"); 
   } 
}

संकलन करने पर, उपरोक्त कार्यक्रम आपको निम्नलिखित परिणाम देता है -

Connected to the database successfully 
Collection created successfully

एक संग्रह प्राप्त करना / चयन करना

डेटाबेस से एक संग्रह प्राप्त करने / चयन करने के लिए, getCollection() उसकि विधि com.mongodb.client.MongoDatabase वर्ग का उपयोग किया जाता है।

निम्नलिखित एक संग्रह प्राप्त करने / चयन करने का कार्यक्रम है -

import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase; 

import org.bson.Document; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class selectingCollection { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 
     
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb");  
      
      // Creating a collection 
      System.out.println("Collection created successfully"); 

      // Retieving a collection
      MongoCollection<Document> collection = database.getCollection("myCollection"); 
      System.out.println("Collection myCollection selected successfully"); 
   }
}

संकलन करने पर, उपरोक्त कार्यक्रम आपको निम्नलिखित परिणाम देता है -

Connected to the database successfully 
Collection created successfully 
Collection myCollection selected successfully

एक दस्तावेज़ डालें

MongoDB में एक दस्तावेज़ सम्मिलित करने के लिए, insert() उसकि विधि com.mongodb.client.MongoCollection वर्ग का उपयोग किया जाता है।

दस्तावेज़ सम्मिलित करने के लिए कोड स्निपेट निम्नलिखित है -

import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase; 

import org.bson.Document;  
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class InsertingDocument { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 

      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 

      // Retrieving a collection
      MongoCollection<Document> collection = database.getCollection("sampleCollection"); 
      System.out.println("Collection sampleCollection selected successfully");

      Document document = new Document("title", "MongoDB") 
      .append("id", 1)
      .append("description", "database") 
      .append("likes", 100) 
      .append("url", "http://www.tutorialspoint.com/mongodb/") 
      .append("by", "tutorials point");  
      collection.insertOne(document); 
      System.out.println("Document inserted successfully");     
   } 
}

संकलन करने पर, उपरोक्त कार्यक्रम आपको निम्नलिखित परिणाम देता है -

Connected to the database successfully 
Collection sampleCollection selected successfully 
Document inserted successfully

सभी दस्तावेज़ों को पुनः प्राप्त करें

संग्रह से सभी दस्तावेजों का चयन करने के लिए, find() उसकि विधि com.mongodb.client.MongoCollectionवर्ग का उपयोग किया जाता है। यह विधि एक कर्सर लौटाती है, इसलिए आपको इस कर्सर को पुनरावृत्त करना होगा।

निम्नलिखित सभी दस्तावेजों का चयन करने का कार्यक्रम है -

import com.mongodb.client.FindIterable; 
import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase;  

import java.util.Iterator; 
import org.bson.Document; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class RetrievingAllDocuments { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 

      // Creating Credentials 
      MongoCredential credential;
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb");  
      
      // Retrieving a collection 
      MongoCollection<Document> collection = database.getCollection("sampleCollection");
      System.out.println("Collection sampleCollection selected successfully"); 

      // Getting the iterable object 
      FindIterable<Document> iterDoc = collection.find(); 
      int i = 1; 

      // Getting the iterator 
      Iterator it = iterDoc.iterator(); 
    
      while (it.hasNext()) {  
         System.out.println(it.next());  
      i++; 
      }
   } 
}

संकलन करने पर, उपरोक्त कार्यक्रम आपको निम्नलिखित परिणाम देता है -

Document{{
   _id = 5967745223993a32646baab8, 
   title = MongoDB, 
   id = 1, 
   description = database, 
   likes = 100, 
   url = http://www.tutorialspoint.com/mongodb/, by = tutorials point
}}  
Document{{
   _id = 7452239959673a32646baab8, 
   title = RethinkDB, 
   id = 2, 
   description = database, 
   likes = 200, 
   url = http://www.tutorialspoint.com/rethinkdb/, by = tutorials point
}}

दस्तावेज़ अद्यतन करें

संग्रह से एक दस्तावेज़ को अद्यतन करने के लिए, updateOne() उसकि विधि com.mongodb.client.MongoCollection वर्ग का उपयोग किया जाता है।

निम्नलिखित पहला दस्तावेज चुनने का कार्यक्रम है -

import com.mongodb.client.FindIterable; 
import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase; 
import com.mongodb.client.model.Filters; 
import com.mongodb.client.model.Updates; 

import java.util.Iterator; 
import org.bson.Document;  
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class UpdatingDocuments { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 
     
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 

      // Retrieving a collection 
      MongoCollection<Document> collection = database.getCollection("sampleCollection");
      System.out.println("Collection myCollection selected successfully"); 

      collection.updateOne(Filters.eq("id", 1), Updates.set("likes", 150));       
      System.out.println("Document update successfully...");  
      
      // Retrieving the documents after updation 
      // Getting the iterable object
      FindIterable<Document> iterDoc = collection.find(); 
      int i = 1; 

      // Getting the iterator 
      Iterator it = iterDoc.iterator(); 

      while (it.hasNext()) {  
         System.out.println(it.next());  
         i++; 
      }     
   }  
}

संकलन करने पर, उपरोक्त कार्यक्रम आपको निम्नलिखित परिणाम देता है -

Document update successfully... 
Document {{
   _id = 5967745223993a32646baab8, 
   title = MongoDB, 
   id = 1, 
   description = database, 
   likes = 150, 
   url = http://www.tutorialspoint.com/mongodb/, by = tutorials point
}}

एक दस्तावेज़ हटाएँ

संग्रह से एक दस्तावेज़ को हटाने के लिए, आपको लिंक का उपयोग करने की आवश्यकता है deleteOne() की विधि com.mongodb.client.MongoCollection कक्षा।

दस्तावेज़ को हटाने का कार्यक्रम निम्नलिखित है -

import com.mongodb.client.FindIterable; 
import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase; 
import com.mongodb.client.model.Filters;  

import java.util.Iterator; 
import org.bson.Document; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class DeletingDocuments { 
   
   public static void main( String args[] ) {  
   
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 );
      
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 

      // Retrieving a collection
      MongoCollection<Document> collection = database.getCollection("sampleCollection");
      System.out.println("Collection sampleCollection selected successfully"); 

      // Deleting the documents 
      collection.deleteOne(Filters.eq("id", 1)); 
      System.out.println("Document deleted successfully...");  
      
      // Retrieving the documents after updation 
      // Getting the iterable object 
      FindIterable<Document> iterDoc = collection.find(); 
      int i = 1; 

      // Getting the iterator 
      Iterator it = iterDoc.iterator(); 

      while (it.hasNext()) {  
         System.out.println("Inserted Document: "+i);  
         System.out.println(it.next());  
         i++; 
      }       
   } 
}

संकलन करने पर, उपरोक्त कार्यक्रम आपको निम्नलिखित परिणाम देता है -

Connected to the database successfully 
Collection sampleCollection selected successfully 
Document deleted successfully...

एक संग्रह छोड़ने

एक डेटाबेस से एक संग्रह को छोड़ने के लिए, आपको डेटाबेस का उपयोग करने की आवश्यकता है drop() की विधि com.mongodb.client.MongoCollection कक्षा।

निम्नलिखित एक संग्रह को हटाने का कार्यक्रम है -

import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase;  

import org.bson.Document;  
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class DropingCollection { 
   
   public static void main( String args[] ) {  

      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 

      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb");  
      
      // Creating a collection 
      System.out.println("Collections created successfully"); 

      // Retieving a collection
      MongoCollection<Document> collection = database.getCollection("sampleCollection");

      // Dropping a Collection 
      collection.drop(); 
      System.out.println("Collection dropped successfully");
   } 
}

संकलन करने पर, उपरोक्त कार्यक्रम आपको निम्नलिखित परिणाम देता है -

Connected to the database successfully 
Collection sampleCollection selected successfully 
Collection dropped successfully

सभी संग्रहों को सूचीबद्ध करना

एक डेटाबेस में सभी संग्रह को सूचीबद्ध करने के लिए, आपको उपयोग करने की आवश्यकता है listCollectionNames() की विधि com.mongodb.client.MongoDatabase कक्षा।

डेटाबेस के सभी संग्रह को सूचीबद्ध करने का कार्यक्रम निम्नलिखित है -

import com.mongodb.client.MongoDatabase; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class ListOfCollection { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 

      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 

      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 
      System.out.println("Collection created successfully"); 
      for (String name : database.listCollectionNames()) { 
         System.out.println(name); 
      } 
   }
}

संकलन करने पर, उपरोक्त कार्यक्रम आपको निम्नलिखित परिणाम देता है -

Connected to the database successfully 
Collection created successfully 
myCollection 
myCollection1 
myCollection5

शेष MongoDB विधियाँ save(), limit(), skip(), sort() आदि उसी तरह से काम करते हैं जैसा कि बाद के ट्यूटोरियल में बताया गया है।

PHP के साथ MongoDB का उपयोग करने के लिए, आपको MongoDB PHP ड्राइवर का उपयोग करने की आवश्यकता है। Url से ड्राइवर डाउनलोड करें PHP ड्राइवर डाउनलोड करें । इसके नवीनतम रिलीज को डाउनलोड करना सुनिश्चित करें। अब संग्रह को अनज़िप करें और php_mongo.dll को अपने PHP एक्सटेंशन डायरेक्टरी ("डिफ़ॉल्ट रूप से" एक्सट्रीम) में डालें और अपनी php.ini फ़ाइल में निम्न पंक्ति जोड़ें -

extension = php_mongo.dll

एक कनेक्शन बनाएं और एक डेटाबेस का चयन करें

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

डेटाबेस से जुड़ने के लिए कोड स्निपेट निम्नलिखित है -

<?php
   // connect to mongodb
   $m = new MongoClient();
	
   echo "Connection to database successfully";
   // select a database
   $db = $m->mydb;
	
   echo "Database mydb selected";
?>

जब कार्यक्रम निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम देगा -

Connection to database successfully
Database mydb selected

एक संग्रह बनाएँ

निम्नलिखित एक संग्रह बनाने के लिए कोड स्निपेट है -

<?php
   // connect to mongodb
   $m = new MongoClient(); echo "Connection to database successfully"; // select a database $db = $m->mydb; echo "Database mydb selected"; $collection = $db->createCollection("mycol");
   echo "Collection created succsessfully";
?>

जब कार्यक्रम निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम देगा -

Connection to database successfully
Database mydb selected
Collection created succsessfully

एक दस्तावेज़ डालें

MongoDB में एक दस्तावेज़ सम्मिलित करने के लिए, insert() विधि का उपयोग किया जाता है।

दस्तावेज़ सम्मिलित करने के लिए कोड स्निपेट निम्नलिखित है -

<?php
   // connect to mongodb
   $m = new MongoClient();
   echo "Connection to database successfully";
	
   // select a database
   $db = $m->mydb;
   echo "Database mydb selected";
   $collection = $db->mycol;
   echo "Collection selected succsessfully";
	
   $document = array( "title" => "MongoDB", "description" => "database", "likes" => 100, "url" => "http://www.tutorialspoint.com/mongodb/", "by" => "tutorials point" ); $collection->insert($document);
   echo "Document inserted successfully";
?>

जब कार्यक्रम निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम देगा -

Connection to database successfully
Database mydb selected
Collection selected succsessfully
Document inserted successfully

सभी दस्तावेज़ ढूँढें

संग्रह से सभी दस्तावेजों का चयन करने के लिए, () विधि का उपयोग किया जाता है।

सभी दस्तावेजों का चयन करने के लिए कोड स्निपेट निम्नलिखित है -

<?php
   // connect to mongodb
   $m = new MongoClient();
   echo "Connection to database successfully";
	
   // select a database
   $db = $m->mydb;
   echo "Database mydb selected";
   $collection = $db->mycol;
   echo "Collection selected succsessfully";

   $cursor = $collection->find();
   // iterate cursor to display title of documents
	
   foreach ($cursor as $document) {
      echo $document["title"] . "\n";
   }
?>

जब कार्यक्रम निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम देगा -

Connection to database successfully
Database mydb selected
Collection selected succsessfully {
   "title": "MongoDB"
}

एक दस्तावेज़ को अपडेट करें

किसी दस्तावेज़ को अपडेट करने के लिए, आपको अपडेट () विधि का उपयोग करना होगा।

निम्नलिखित उदाहरण में, हम सम्मिलित दस्तावेज़ के शीर्षक को अपडेट करेंगे MongoDB Tutorial। दस्तावेज़ को अपडेट करने के लिए कोड स्निपेट निम्नलिखित है -

<?php
   // connect to mongodb
   $m = new MongoClient();
   echo "Connection to database successfully";
	
   // select a database
   $db = $m->mydb;
   echo "Database mydb selected";
   $collection = $db->mycol;
   echo "Collection selected succsessfully";

   // now update the document
   $collection->update(array("title"=>"MongoDB"), array('$set'=>array("title"=>"MongoDB Tutorial")));
   echo "Document updated successfully";
	
   // now display the updated document
   $cursor = $collection->find();
	
   // iterate cursor to display title of documents
   echo "Updated document";
	
   foreach ($cursor as $document) {
      echo $document["title"] . "\n";
   }
?>

जब कार्यक्रम निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम देगा -

Connection to database successfully
Database mydb selected
Collection selected succsessfully
Document updated successfully
Updated document {
   "title": "MongoDB Tutorial"
}

एक दस्तावेज़ हटाएँ

किसी दस्तावेज़ को हटाने के लिए, आपको निष्कासन () विधि का उपयोग करना होगा।

निम्नलिखित उदाहरण में, हम उन दस्तावेजों को हटा देंगे जिनके पास शीर्षक है MongoDB Tutorial। दस्तावेज़ को हटाने के लिए कोड स्निपेट निम्नलिखित है -

<?php
   // connect to mongodb
   $m = new MongoClient();
   echo "Connection to database successfully";
	
   // select a database
   $db = $m->mydb;
   echo "Database mydb selected";
   $collection = $db->mycol;
   echo "Collection selected succsessfully";
   
   // now remove the document
   $collection->remove(array("title"=>"MongoDB Tutorial"),false); echo "Documents deleted successfully"; // now display the available documents $cursor = $collection->find(); // iterate cursor to display title of documents echo "Updated document"; foreach ($cursor as $document) { echo $document["title"] . "\n";
   }
?>

जब कार्यक्रम निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम देगा -

Connection to database successfully
Database mydb selected
Collection selected succsessfully
Documents deleted successfully

उपरोक्त उदाहरण में, दूसरा पैरामीटर बूलियन प्रकार है और इसके लिए उपयोग किया जाता है justOne का क्षेत्र remove() तरीका।

शेष MongoDB विधियाँ findOne(), save(), limit(), skip(), sort() आदि वही है जो ऊपर बताया गया है।

MongoDB में संबंध दर्शाते हैं कि विभिन्न दस्तावेज तार्किक रूप से एक-दूसरे से कैसे संबंधित हैं। रिश्ते के माध्यम से मॉडलिंग की जा सकती हैEmbedded तथा Referencedदृष्टिकोण। इस तरह के रिश्ते 1: 1, 1: N, N: 1 या N: N हो सकते हैं।

आइए हम उपयोगकर्ताओं के लिए पते संग्रहीत करने के मामले पर विचार करें। इसलिए, एक उपयोगकर्ता के पास 1: N संबंध बनाने वाले कई पते हो सकते हैं।

निम्नलिखित नमूना दस्तावेज़ संरचना है user दस्तावेज़ -

{
   "_id":ObjectId("52ffc33cd85242f436000001"),
   "name": "Tom Hanks",
   "contact": "987654321",
   "dob": "01-01-1991"
}

निम्नलिखित नमूना दस्तावेज़ संरचना है address दस्तावेज़ -

{
   "_id":ObjectId("52ffc4a5d85242602e000000"),
   "building": "22 A, Indiana Apt",
   "pincode": 123456,
   "city": "Los Angeles",
   "state": "California"
}

मॉडलिंग एंबेडेड रिश्ते

एम्बेडेड दृष्टिकोण में, हम उपयोगकर्ता दस्तावेज़ के अंदर पता दस्तावेज़ को एम्बेड करेंगे।

{
   "_id":ObjectId("52ffc33cd85242f436000001"),
   "contact": "987654321",
   "dob": "01-01-1991",
   "name": "Tom Benzamin",
   "address": [
      {
         "building": "22 A, Indiana Apt",
         "pincode": 123456,
         "city": "Los Angeles",
         "state": "California"
      },
      {
         "building": "170 A, Acropolis Apt",
         "pincode": 456789,
         "city": "Chicago",
         "state": "Illinois"
      }
   ]
}

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

>db.users.findOne({"name":"Tom Benzamin"},{"address":1})

ध्यान दें कि उपरोक्त क्वेरी में, db तथा users क्रमशः डेटाबेस और संग्रह हैं।

दोष यह है कि यदि एम्बेडेड दस्तावेज़ आकार में बहुत अधिक बढ़ता रहता है, तो यह पढ़ने / लिखने के प्रदर्शन को प्रभावित कर सकता है।

मॉडलिंग रिफरेंस रिलेशनशिप

यह सामान्यीकृत संबंधों को डिजाइन करने का दृष्टिकोण है। इस दृष्टिकोण में, उपयोगकर्ता और पते के दस्तावेज़ दोनों को अलग-अलग रखा जाएगा, लेकिन उपयोगकर्ता दस्तावेज़ में एक फ़ील्ड होगा जो पते दस्तावेज़ का संदर्भ देगाid मैदान।

{
   "_id":ObjectId("52ffc33cd85242f436000001"),
   "contact": "987654321",
   "dob": "01-01-1991",
   "name": "Tom Benzamin",
   "address_ids": [
      ObjectId("52ffc4a5d85242602e000000"),
      ObjectId("52ffc4a5d85242602e000001")
   ]
}

जैसा कि ऊपर दिखाया गया है, उपयोगकर्ता दस्तावेज़ में सरणी फ़ील्ड है address_idsजिसमें संबंधित पते के ऑब्जेक्ट शामिल हैं। इन ObjectIds का उपयोग करके, हम पते के दस्तावेजों को क्वेरी कर सकते हैं और वहां से पते का विवरण प्राप्त कर सकते हैं। इस दृष्टिकोण के साथ, हमें दो प्रश्नों की आवश्यकता होगी: पहले लाने के लिएaddress_ids खेतों से user इन पतों को लाने के लिए दस्तावेज़ और दूसरा address संग्रह।

>var result = db.users.findOne({"name":"Tom Benzamin"},{"address_ids":1})
>var addresses = db.address.find({"_id":{"$in":result["address_ids"]}})

जैसा कि MongoDB संबंधों के अंतिम अध्याय में देखा गया है, MongoDB में एक सामान्यीकृत डेटाबेस संरचना को लागू करने के लिए, हम की अवधारणा का उपयोग करते हैं Referenced Relationships के रूप में भी संदर्भित Manual Referencesजिसमें हम मैन्युअल रूप से संदर्भित दस्तावेज़ की आईडी को अन्य दस्तावेज़ के अंदर संग्रहीत करते हैं। हालांकि, ऐसे मामलों में जहां एक दस्तावेज में विभिन्न संग्रह से संदर्भ होते हैं, हम उपयोग कर सकते हैंMongoDB DBRefs

DBRefs बनाम मैनुअल सन्दर्भ

एक उदाहरण परिदृश्य के रूप में, जहां हम मैनुअल संदर्भों के बजाय DBRefs का उपयोग करेंगे, एक डेटाबेस पर विचार करें जहां हम विभिन्न संग्रह (एड्रेस_होम, एड्रेस_ऑफिस, एड्रेस-हेडिंग, आदि) में विभिन्न प्रकार के पते (घर, कार्यालय, मेलिंग, आदि) संग्रहीत कर रहे हैं। अब, जब एuserसंग्रह का दस्तावेज एक पते का संदर्भ देता है, यह भी निर्दिष्ट करने की आवश्यकता है कि पता प्रकार के आधार पर किस संग्रह को देखना है। ऐसे परिदृश्यों में जहां एक दस्तावेज़ कई संग्रह से दस्तावेजों का संदर्भ देता है, हमें डीबीआरएफ का उपयोग करना चाहिए।

DBRefs का उपयोग करना

DBRefs में तीन क्षेत्र हैं -

  • $ref - यह फ़ील्ड संदर्भित दस्तावेज़ के संग्रह को निर्दिष्ट करता है

  • $id - यह फ़ील्ड संदर्भित दस्तावेज़ के _id फ़ील्ड को निर्दिष्ट करता है

  • $db - यह एक वैकल्पिक क्षेत्र है और इसमें डेटाबेस का नाम है जिसमें संदर्भित दस्तावेज निहित है

DBRef फ़ील्ड वाले एक नमूना उपयोगकर्ता दस्तावेज़ पर विचार करें address जैसा कि कोड स्निपेट में दिखाया गया है -

{
   "_id":ObjectId("53402597d852426020000002"),
   "address": {
   "$ref": "address_home", "$id": ObjectId("534009e4d852427820000002"),
   "$db": "tutorialspoint"},
   "contact": "987654321",
   "dob": "01-01-1991",
   "name": "Tom Benzamin"
}

address यहाँ DBRef फ़ील्ड निर्दिष्ट करती है कि संदर्भित पता दस्तावेज़ में निहित है address_home के तहत संग्रह tutorialspoint डेटाबेस और 534009e4d852427820000002 की एक आईडी है।

निम्न कोड गतिशील रूप से निर्दिष्ट संग्रह में दिखता है $ref पैरामीटर (address_home हमारे मामले में) द्वारा निर्दिष्ट आईडी के साथ एक दस्तावेज के लिए $id DBRef में पैरामीटर।

>var user = db.users.findOne({"name":"Tom Benzamin"})
>var dbRef = user.address
>db[dbRef.$ref].findOne({"_id":(dbRef.$id)})

उपरोक्त कोड में मौजूद निम्न पता दस्तावेज़ को लौटाता है address_home संग्रह -

{
   "_id" : ObjectId("534009e4d852427820000002"),
   "building" : "22 A, Indiana Apt",
   "pincode" : 123456,
   "city" : "Los Angeles",
   "state" : "California"
}

इस अध्याय में, हम कवर किए गए प्रश्नों के बारे में जानेंगे।

एक कवर किया गया प्रश्न क्या है?

आधिकारिक MongoDB प्रलेखन के अनुसार, एक कवर की गई क्वेरी एक क्वेरी है जिसमें -

  • क्वेरी में सभी फ़ील्ड एक अनुक्रमणिका का हिस्सा हैं।
  • क्वेरी में दिए गए सभी फ़ील्ड एक ही सूचकांक में हैं।

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

कवर की गई क्वेरीज़ का उपयोग करना

कवर किए गए प्रश्नों का परीक्षण करने के लिए, निम्नलिखित दस्तावेज़ पर विचार करें users संग्रह -

{
   "_id": ObjectId("53402597d852426020000002"),
   "contact": "987654321",
   "dob": "01-01-1991",
   "gender": "M",
   "name": "Tom Benzamin",
   "user_name": "tombenzamin"
}

हम पहले के लिए एक कंपाउंड इंडेक्स बनाएंगे users खेतों पर संग्रह gender तथा user_name निम्नलिखित प्रश्न का उपयोग कर -

>db.users.ensureIndex({gender:1,user_name:1})

अब, यह सूचकांक निम्नलिखित प्रश्न को कवर करेगा -

>db.users.find({gender:"M"},{user_name:1,_id:0})

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

चूंकि हमारे सूचकांक में शामिल नहीं है _idफ़ील्ड, हमने अपनी क्वेरी के परिणाम सेट से स्पष्ट रूप से बाहर रखा है, क्योंकि हर क्वेरी में डिफ़ॉल्ट रिटर्न _id फ़ील्ड द्वारा MongoDB है। तो निम्नलिखित क्वेरी ऊपर बनाए गए इंडेक्स के अंदर कवर नहीं की गई होगी -

>db.users.find({gender:"M"},{user_name:1})

अंत में, याद रखें कि यदि कोई सूचकांक क्वेरी को कवर नहीं कर सकता है तो -

  • कोई भी अनुक्रमित फ़ील्ड एक सरणी है
  • अनुक्रमित फ़ील्ड्स में से कोई भी एक उप-साख है

डेटाबेस और इंडेक्सिंग डिज़ाइन कितना प्रभावी है, यह मापने के लिए क्वेरीज़ का विश्लेषण एक बहुत महत्वपूर्ण पहलू है। हम अक्सर उपयोग किए जाने के बारे में जानेंगे$explain तथा $hint प्रश्नों।

$ समझाने का उपयोग करना

$explainऑपरेटर क्वेरी और अन्य आँकड़ों में प्रयुक्त क्वेरी, इंडेक्स पर जानकारी प्रदान करता है। यह विश्लेषण करते समय बहुत उपयोगी है कि आपके अनुक्रमणिका को कितनी अच्छी तरह से अनुकूलित किया गया है।

पिछले अध्याय में, हमने पहले ही एक सूचकांक बनाया था users खेतों पर संग्रह gender तथा user_name निम्नलिखित प्रश्न का उपयोग कर -

>db.users.ensureIndex({gender:1,user_name:1})

अब हम उपयोग करेंगे $explain निम्नलिखित प्रश्न पर -

>db.users.find({gender:"M"},{user_name:1,_id:0}).explain()

उपरोक्त व्याख्या () क्वेरी निम्नलिखित विश्लेषण परिणाम लौटाती है -

{
   "cursor" : "BtreeCursor gender_1_user_name_1",
   "isMultiKey" : false,
   "n" : 1,
   "nscannedObjects" : 0,
   "nscanned" : 1,
   "nscannedObjectsAllPlans" : 0,
   "nscannedAllPlans" : 1,
   "scanAndOrder" : false,
   "indexOnly" : true,
   "nYields" : 0,
   "nChunkSkips" : 0,
   "millis" : 0,
   "indexBounds" : {
      "gender" : [
         [
            "M",
            "M"
         ]
      ],
      "user_name" : [
         [
            {
               "$minElement" : 1 }, { "$maxElement" : 1
            }
         ]
      ]
   }
}

अब हम इस परिणाम सेट में खेतों को देखेंगे -

  • का सही मूल्य indexOnly इंगित करता है कि इस क्वेरी ने अनुक्रमण का उपयोग किया है।

  • cursorफ़ील्ड उपयोग किए गए कर्सर के प्रकार को निर्दिष्ट करता है। BTreeCursor प्रकार इंगित करता है कि एक सूचकांक का उपयोग किया गया था और उपयोग किए गए सूचकांक का नाम भी देता है। BasicCursor इंगित करता है कि किसी भी इंडेक्स का उपयोग किए बिना एक पूर्ण स्कैन किया गया था।

  • n मिलान किए गए दस्तावेज़ों की संख्या इंगित करता है।

  • nscannedObjects स्कैन किए गए दस्तावेजों की कुल संख्या को इंगित करता है।

  • nscanned स्कैन किए गए दस्तावेज़ों या सूचकांक प्रविष्टियों की कुल संख्या इंगित करता है।

$ संकेत का उपयोग करना

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

>db.users.find({gender:"M"},{user_name:1,_id:0}).hint({gender:1,user_name:1})

$ व्याख्या का उपयोग करके उपरोक्त क्वेरी का विश्लेषण करने के लिए -

>db.users.find({gender:"M"},{user_name:1,_id:0}).hint({gender:1,user_name:1}).explain()

परमाणु संचालन के लिए मॉडल डेटा

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

निम्नलिखित उत्पादों के दस्तावेज़ पर विचार करें -

{
   "_id":1,
   "product_name": "Samsung S3",
   "category": "mobiles",
   "product_total": 5,
   "product_available": 3,
   "product_bought_by": [
      {
         "customer": "john",
         "date": "7-Jan-2014"
      },
      {
         "customer": "mark",
         "date": "8-Jan-2014"
      }
   ]
}

इस दस्तावेज़ में, हमने उस ग्राहक की जानकारी एम्बेड की है जो उत्पाद को खरीदता है product_bought_byमैदान। अब, जब भी कोई नया ग्राहक उत्पाद खरीदता है, तो हम पहले जांच लेंगे कि उत्पाद अभी भी उपलब्ध है या नहींproduct_availableमैदान। यदि उपलब्ध हो, तो हम product_available फ़ील्ड के मूल्य को कम कर देंगे और साथ ही product_bought_by फ़ील्ड में नए ग्राहक के एम्बेडेड दस्तावेज़ सम्मिलित करेंगे। हम इस्तेमाल करेंगेfindAndModify इस कार्यक्षमता के लिए कमांड क्योंकि यह एक ही बार में दस्तावेज़ को खोजता है और अपडेट करता है।

>db.products.findAndModify({ 
   query:{_id:2,product_available:{$gt:0}}, 
   update:{ 
      $inc:{product_available:-1}, $push:{product_bought_by:{customer:"rob",date:"9-Jan-2014"}} 
   }    
})

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

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

निम्नलिखित दस्तावेज़ पर विचार करें users संग्रह -

{
   "address": {
      "city": "Los Angeles",
      "state": "California",
      "pincode": "123"
   },
   "tags": [
      "music",
      "cricket",
      "blogs"
   ],
   "name": "Tom Benzamin"
}

उपरोक्त दस्तावेज में ए address sub-document और एक tags array

इंडेक्सिंग एरे फील्ड्स

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

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

टैग सरणी पर एक इंडेक्स बनाने के लिए, निम्नलिखित कोड का उपयोग करें -

>db.users.ensureIndex({"tags":1})

सूचकांक बनाने के बाद, हम इस तरह संग्रह के टैग क्षेत्र पर खोज कर सकते हैं -

>db.users.find({tags:"cricket"})

यह सत्यापित करने के लिए कि उचित अनुक्रमण का उपयोग किया जाता है, निम्न का उपयोग करें explain कमांड -

>db.users.find({tags:"cricket"}).explain()

उपरोक्त आदेश के परिणामस्वरूप "कर्सर": "BtreeCursor tags_1" जो पुष्टि करता है कि उचित अनुक्रमण का उपयोग किया जाता है।

अनुक्रमण दस्तावेज़ दस्तावेज़ फ़ील्ड्स

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

उप-दस्तावेज़ के सभी तीन क्षेत्रों पर एक सूचकांक बनाने के लिए, निम्नलिखित कोड का उपयोग करें -

>db.users.ensureIndex({"address.city":1,"address.state":1,"address.pincode":1})

एक बार इंडेक्स बनने के बाद, हम इस इंडेक्स का उपयोग करने वाले किसी भी सब-डॉक्यूमेंट फ़ील्ड को निम्नानुसार खोज सकते हैं -

>db.users.find({"address.city":"Los Angeles"})

याद रखें कि क्वेरी अभिव्यक्ति को निर्दिष्ट सूचकांक के आदेश का पालन करना है। तो ऊपर बनाया गया सूचकांक निम्नलिखित प्रश्नों का समर्थन करेगा -

>db.users.find({"address.city":"Los Angeles","address.state":"California"})

यह निम्नलिखित प्रश्न का भी समर्थन करेगा -

>db.users.find({"address.city":"LosAngeles","address.state":"California",
   "address.pincode":"123"})

इस अध्याय में, हम अनुक्रमण सीमाओं और इसके अन्य घटकों के बारे में जानेंगे।

अतिरिक्त उपरि

प्रत्येक इंडेक्स में कुछ स्थान होता है और साथ ही प्रत्येक इन्सर्ट, अपडेट और डिलीट पर एक ओवरहेड होता है। इसलिए यदि आप शायद ही कभी अपने संग्रह को पढ़ने के संचालन के लिए उपयोग करते हैं, तो यह समझ में आता है कि अनुक्रमित का उपयोग न करें

रैम उपयोग

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

क्वेरी की सीमाएँ

अनुक्रमण का उपयोग उन प्रश्नों में नहीं किया जा सकता है जो उपयोग करते हैं -

  • रेगुलर एक्सप्रेशन या निगेटिव ऑपरेटर्स जैसे $nin, $नहीं, आदि।
  • अंकगणित ऑपरेटरों जैसे $ आधुनिक, आदि।
  • $ जहां खंड

इसलिए, आपके प्रश्नों के लिए अनुक्रमणिका के उपयोग की जाँच करना हमेशा उचित होता है।

सूचकांक कुंजी सीमाएँ

2.6 संस्करण से शुरू, MongoDB एक इंडेक्स नहीं बनाएगा यदि मौजूदा इंडेक्स फ़ील्ड का मूल्य इंडेक्स कुंजी सीमा से अधिक है।

सूचकांक कुंजी सीमा से अधिक दस्तावेज़ सम्मिलित करना

यदि इस दस्तावेज़ का अनुक्रमित फ़ील्ड मान इंडेक्स कुंजी सीमा से अधिक है, तो MongoDB किसी भी दस्तावेज़ को अनुक्रमित संग्रह में सम्मिलित नहीं करेगा। यही हाल मोंगोरेस्टोर और मोंगोइमपोर्ट उपयोगिताओं का है।

अधिकतम रेंज

  • एक संग्रह में 64 से अधिक सूचकांक नहीं हो सकते।
  • इंडेक्स नाम की लंबाई 125 अक्षरों से अधिक नहीं हो सकती है।
  • एक कंपाउंड इंडेक्स में अधिकतम 31 फील्ड इंडेक्स हो सकते हैं।

हम पिछले सभी अध्यायों में MongoDB Object Id का उपयोग करते रहे हैं। इस अध्याय में, हम ObjectId की संरचना को समझेंगे।

एक ObjectId 12-बाइट BSON प्रकार निम्नलिखित संरचना है -

  • यूनिक्स युग से पहले 4 बाइट्स सेकंड का प्रतिनिधित्व करते हैं
  • अगले 3 बाइट्स मशीन पहचानकर्ता हैं
  • अगले 2 बाइट्स होते हैं process id
  • अंतिम 3 बाइट्स एक यादृच्छिक काउंटर मान हैं

MongoDB डिफ़ॉल्ट मान के रूप में ObjectIds का उपयोग करता है _idप्रत्येक दस्तावेज़ का क्षेत्र, जो किसी भी दस्तावेज़ के निर्माण के दौरान उत्पन्न होता है। ObjectId का जटिल संयोजन सभी _id क्षेत्रों को विशिष्ट बनाता है।

नई वस्तु का निर्माण

एक नया ObjectId उत्पन्न करने के लिए निम्नलिखित कोड का उपयोग करें -

>newObjectId = ObjectId()

उपरोक्त कथन ने निम्नलिखित विशिष्ट आईडी को लौटा दिया -

ObjectId("5349b4ddd2781d08c09890f3")

MongoDB के बजाय ObjectId बनाने के लिए, आप एक 12-बाइट आईडी भी प्रदान कर सकते हैं -

>myObjectId = ObjectId("5349b4ddd2781d08c09890f4")

एक दस्तावेज़ का टाइमस्टैम्प बनाना

चूंकि डिफ़ॉल्ट ऑब्जेक्ट द्वारा _id ऑब्जेक्ट 4-बाइट टाइमस्टैम्प को संग्रहीत करता है, ज्यादातर मामलों में आपको किसी भी दस्तावेज़ के निर्माण समय को संग्रहीत करने की आवश्यकता नहीं होती है। आप getTimestamp विधि का उपयोग करके दस्तावेज़ के निर्माण का समय ले सकते हैं -

>ObjectId("5349b4ddd2781d08c09890f4").getTimestamp()

यह आईएसओ तिथि प्रारूप में इस दस्तावेज के निर्माण का समय लौटाएगा -

ISODate("2014-04-12T21:49:17Z")

स्ट्रिंग के लिए ObjectId परिवर्तित

कुछ मामलों में, आपको एक स्ट्रिंग प्रारूप में ObjectId के मूल्य की आवश्यकता हो सकती है। ऑब्जेक्ट को स्ट्रिंग में बदलने के लिए, निम्नलिखित कोड का उपयोग करें -

>newObjectId.str

उपरोक्त कोड दिशानिर्देश का स्ट्रिंग प्रारूप लौटाएगा -

5349b4ddd2781d08c09890f3

MongoDB प्रलेखन के अनुसार, Map-reduceएक डेटा प्रोसेसिंग प्रतिमान है जो डेटा के बड़े संस्करणों को उपयोगी समग्र परिणामों में संघनित करने के लिए है। MongoDB का उपयोग करता हैmapReduceमानचित्र-कम संचालन के लिए कमांड। MapReduce का उपयोग आमतौर पर बड़े डेटा सेटों के प्रसंस्करण के लिए किया जाता है।

MapReduce कमांड

निम्नलिखित मूल MapReduce कमांड का सिंटैक्स है -

>db.collection.mapReduce(
   function() {emit(key,value);},  //map function
   function(key,values) {return reduceFunction}, {   //reduce function
      out: collection,
      query: document,
      sort: document,
      limit: number
   }
)

मानचित्र-कम फ़ंक्शन पहले संग्रह पर सवाल उठाता है, फिर कुंजी-मूल्य जोड़े का उत्सर्जन करने के लिए परिणाम दस्तावेज़ों को मैप करता है, जो बाद में उन मानों के आधार पर कम हो जाते हैं जिनमें कई मान होते हैं।

उपरोक्त वाक्य रचना में -

  • map एक जावास्क्रिप्ट फ़ंक्शन है जो एक कुंजी के साथ एक मूल्य को मैप करता है और एक कुंजी-मूल्य जोड़ी का उत्सर्जन करता है

  • reduce एक जावास्क्रिप्ट फ़ंक्शन है जो एक ही कुंजी वाले सभी दस्तावेजों को कम या समूहित करता है

  • out मैप-कम क्वेरी परिणाम के स्थान को निर्दिष्ट करता है

  • query दस्तावेजों के चयन के लिए वैकल्पिक चयन मानदंड निर्दिष्ट करता है

  • sort वैकल्पिक सॉर्ट मापदंड को निर्दिष्ट करता है

  • limit निर्दिष्ट किए जाने वाले दस्तावेज़ों की वैकल्पिक अधिकतम संख्या निर्दिष्ट करता है

MapReduce का उपयोग करना

उपयोगकर्ता के पदों को संग्रहीत करते हुए निम्नलिखित दस्तावेज़ संरचना पर विचार करें। दस्तावेज़ उपयोगकर्ता के उपयोगकर्ता_नाम और पोस्ट की स्थिति को संग्रहीत करता है।

{
   "post_text": "tutorialspoint is an awesome website for tutorials",
   "user_name": "mark",
   "status":"active"
}

अब, हम अपने ऊपर एक mapReduce फ़ंक्शन का उपयोग करेंगे posts सभी सक्रिय पोस्टों का चयन करने के लिए संग्रह, उन्हें user_name के आधार पर समूहित करें और फिर निम्नलिखित लिंक का उपयोग करके प्रत्येक उपयोगकर्ता द्वारा पदों की संख्या की गणना करें -

>db.posts.mapReduce( 
   function() { emit(this.user_id,1); }, 
	
   function(key, values) {return Array.sum(values)}, {  
      query:{status:"active"},  
      out:"post_total" 
   }
)

उपरोक्त मेप्रेड्यूस क्वेरी निम्नलिखित परिणाम का उत्पादन करती है -

{
   "result" : "post_total",
   "timeMillis" : 9,
   "counts" : {
      "input" : 4,
      "emit" : 4,
      "reduce" : 2,
      "output" : 2
   },
   "ok" : 1,
}

परिणाम से पता चलता है कि कुल 4 दस्तावेज़ क्वेरी (स्थिति: "सक्रिय") से मेल खाते हैं, मानचित्र फ़ंक्शन ने कुंजी-मूल्य वाले जोड़े के साथ 4 दस्तावेज़ उत्सर्जित किए और अंत में कम फ़ंक्शन समूहीकृत मैप किए गए दस्तावेज़ों में 2 में समान कुंजियाँ हैं।

इस MapReduce क्वेरी के परिणाम को देखने के लिए, खोज ऑपरेटर का उपयोग करें -

>db.posts.mapReduce( 
   function() { emit(this.user_id,1); }, 
   function(key, values) {return Array.sum(values)}, {  
      query:{status:"active"},  
      out:"post_total" 
   }
	
).find()

उपरोक्त क्वेरी निम्नलिखित परिणाम देती है जो इंगित करती है कि दोनों उपयोगकर्ता tom तथा mark सक्रिय राज्यों में दो पद हैं -

{ "_id" : "tom", "value" : 2 }
{ "_id" : "mark", "value" : 2 }

इसी तरह से, बड़े जटिल एकत्रीकरण प्रश्नों के निर्माण के लिए MapReduce Questions का उपयोग किया जा सकता है। कस्टम जावास्क्रिप्ट कार्यों का उपयोग MapReduce का उपयोग करता है जो बहुत लचीला और शक्तिशाली है।

2.4 संस्करण से शुरू, MongoDB ने स्ट्रिंग सामग्री के अंदर खोज करने के लिए टेक्स्ट इंडेक्स का समर्थन करना शुरू किया। Text Search उपजी शब्दों को रोकने के लिए स्ट्रिंग फ़ील्ड में निर्दिष्ट शब्दों को देखने के लिए स्टेमिंग तकनीकों का उपयोग करता है जैसे शब्द a, an, the, आदि वर्तमान में, MongoDB लगभग 15 भाषाओं का समर्थन करता है।

पाठ खोज सक्षम करना

प्रारंभ में, पाठ खोज एक प्रयोगात्मक विशेषता थी लेकिन संस्करण 2.6 से शुरू होकर, कॉन्फ़िगरेशन डिफ़ॉल्ट रूप से सक्षम है। लेकिन यदि आप MongoDB के पिछले संस्करण का उपयोग कर रहे हैं, तो आपको निम्नलिखित कोड के साथ पाठ खोज को सक्षम करना होगा -

>db.adminCommand({setParameter:true,textSearchEnabled:true})

पाठ सूचकांक बनाना

निम्नलिखित दस्तावेज़ पर विचार करें posts पोस्ट पाठ और उसके टैग युक्त संग्रह -

{
   "post_text": "enjoy the mongodb articles on tutorialspoint",
   "tags": [
      "mongodb",
      "tutorialspoint"
   ]
}

हम post_text फ़ील्ड पर एक टेक्स्ट इंडेक्स बनाएंगे ताकि हम अपने पोस्ट के टेक्स्ट के अंदर खोज कर सकें -

>db.posts.ensureIndex({post_text:"text"})

पाठ सूचकांक का उपयोग करना

अब जब हमने post_text फ़ील्ड पर टेक्स्ट इंडेक्स बनाया है, तो हम सभी पदों के लिए शब्द खोजेंगे tutorialspoint उनके पाठ में।

>db.posts.find({$text:{$search:"tutorialspoint"}})

उपरोक्त आदेश में निम्नलिखित परिणाम दस्तावेज हैं जिनके पास शब्द है tutorialspoint उनके पाठ में -

{ 
   "_id" : ObjectId("53493d14d852429c10000002"), 
   "post_text" : "enjoy the mongodb articles on tutorialspoint", 
   "tags" : [ "mongodb", "tutorialspoint" ]
}
{
   "_id" : ObjectId("53493d1fd852429c10000003"), 
   "post_text" : "writing tutorials on mongodb",
   "tags" : [ "mongodb", "tutorial" ] 
}

यदि आप MongoDB के पुराने संस्करणों का उपयोग कर रहे हैं, तो आपको निम्नलिखित कमांड का उपयोग करना होगा -

>db.posts.runCommand("text",{search:" tutorialspoint "})

पाठ खोज का उपयोग सामान्य खोज की तुलना में खोज दक्षता में अत्यधिक सुधार करता है।

पाठ सूचकांक हटाना

मौजूदा टेक्स्ट इंडेक्स को हटाने के लिए, पहले निम्नलिखित क्वेरी का उपयोग करके इंडेक्स का नाम खोजें -

>db.posts.getIndexes()

उपरोक्त क्वेरी से अपने सूचकांक का नाम प्राप्त करने के बाद, निम्न कमांड चलाएँ। यहाँ,post_text_text सूचकांक का नाम है।

>db.posts.dropIndex("post_text_text")

किसी भी स्ट्रिंग में एक पैटर्न या शब्द की खोज के लिए सभी भाषाओं में नियमित अभिव्यक्तियों का अक्सर उपयोग किया जाता है। MongoDB स्ट्रिंग पैटर्न के मिलान के लिए नियमित अभिव्यक्ति की कार्यक्षमता प्रदान करता है$regexऑपरेटर। MongoDB पीसीआर (पर्ल कम्पेटिबल रेगुलर एक्सप्रेशन) को नियमित अभिव्यक्ति भाषा के रूप में उपयोग करता है।

पाठ खोज के विपरीत, हमें नियमित अभिव्यक्ति का उपयोग करने के लिए कोई कॉन्फ़िगरेशन या कमांड करने की आवश्यकता नहीं है।

के तहत निम्नलिखित दस्तावेज़ संरचना पर विचार करें posts पोस्ट पाठ और उसके टैग युक्त संग्रह -

{
   "post_text": "enjoy the mongodb articles on tutorialspoint",
   "tags": [
      "mongodb",
      "tutorialspoint"
   ]
}

रेगेक्स एक्सप्रेशन का उपयोग करना

निम्नलिखित regex क्वेरी स्ट्रिंग वाले सभी पदों के लिए खोज करता है tutorialspoint इसमें -

>db.posts.find({post_text:{$regex:"tutorialspoint"}})

उसी क्वेरी को भी लिखा जा सकता है -

>db.posts.find({post_text:/tutorialspoint/})

केस असंवेदनशील के साथ रेगेक्स एक्सप्रेशन का उपयोग करना

खोज के मामले को असंवेदनशील बनाने के लिए, हम इसका उपयोग करते हैं $options मान के साथ पैरामीटर $i। निम्नलिखित कमांड शब्द होने वाले तार के लिए दिखेगाtutorialspointछोटे या पूंजीगत मामले के बावजूद -

>db.posts.find({post_text:{$regex:"tutorialspoint",$options:"$i"}})

इस क्वेरी से दिए गए परिणामों में से एक निम्नलिखित दस्तावेज है जिसमें शब्द शामिल है tutorialspoint विभिन्न मामलों में -

{
   "_id" : ObjectId("53493d37d852429c10000004"),
   "post_text" : "hey! this is my post on TutorialsPoint", 
   "tags" : [ "tutorialspoint" ]
}

सरणी तत्वों के लिए रेगेक्स का उपयोग करना

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

>db.posts.find({tags:{$regex:"tutorial"}})

नियमित अभिव्यक्ति क्वेरी का अनुकूलन

  • यदि दस्तावेज़ फ़ील्ड हैं indexed, क्वेरी नियमित अभिव्यक्ति से मेल खाने के लिए अनुक्रमित मूल्यों का उपयोग करेगी। यह पूरे संग्रह को स्कैन करने वाली नियमित अभिव्यक्ति की तुलना में खोज को बहुत तेज़ बनाता है।

  • यदि नियमित अभिव्यक्ति ए है prefix expression, सभी मैच एक निश्चित स्ट्रिंग पात्रों के साथ शुरू होने के लिए हैं। उदाहरण के लिए, यदि रेगेक्स अभिव्यक्ति है^tut, फिर क्वेरी को केवल उन स्ट्रिंग्स की खोज करनी है जो इसके साथ शुरू होती हैं tut

RockMongo एक MongoDB प्रशासन उपकरण है, जिसके उपयोग से आप अपने सर्वर, डेटाबेस, संग्रह, दस्तावेज़, अनुक्रमित और बहुत कुछ प्रबंधित कर सकते हैं। यह पढ़ने, लिखने और दस्तावेज़ बनाने के लिए बहुत उपयोगकर्ता के अनुकूल तरीका प्रदान करता है। यह PHP और MySQL के लिए PHPMyAdmin टूल के समान है।

RockMongo डाउनलोड करना

आप यहाँ से RockMongo का नवीनतम संस्करण डाउनलोड कर सकते हैं: https://github.com/iwind/rockmongo

RockMongo स्थापित करना

एक बार डाउनलोड करने के बाद, आप अपने सर्वर रूट फ़ोल्डर में पैकेज को खोल सकते हैं और निकाले गए फ़ोल्डर का नाम बदल सकते हैं rockmongo। कोई भी वेब ब्राउज़र खोलें और एक्सेस करेंindex.phpफ़ोल्डर से पृष्ठ rockmongo। क्रमशः उपयोगकर्ता नाम / पासवर्ड के रूप में व्यवस्थापक / व्यवस्थापक दर्ज करें।

रॉकमॉन्गो के साथ काम करना

अब हम कुछ बुनियादी कार्यों को देख रहे हैं जिन्हें आप रॉकमॉन्गो के साथ कर सकते हैं।

नया डेटाबेस बनाना

एक नया डेटाबेस बनाने के लिए, क्लिक करें Databasesटैब। क्लिकCreate New Database। अगली स्क्रीन पर, नए डेटाबेस का नाम प्रदान करें और क्लिक करेंCreate। आपको एक नया डेटाबेस बाएं पैनल में जोड़ा जाएगा।

नया संग्रह बनाना

डेटाबेस के अंदर एक नया संग्रह बनाने के लिए, बाएं पैनल से उस डेटाबेस पर क्लिक करें। पर क्लिक करेंNew Collectionशीर्ष पर लिंक। संग्रह का आवश्यक नाम प्रदान करें। इस् कैप्ड, साइज़ और मैक्स के अन्य क्षेत्रों के बारे में चिंता न करें। पर क्लिक करेंCreate। एक नया संग्रह बनाया जाएगा और आप इसे बाएं पैनल में देख पाएंगे।

नया दस्तावेज़ बनाना

एक नया दस्तावेज़ बनाने के लिए, उस संग्रह पर क्लिक करें जिसके तहत आप दस्तावेज़ जोड़ना चाहते हैं। जब आप किसी संग्रह पर क्लिक करते हैं, तो आप वहां सूचीबद्ध उस संग्रह के भीतर सभी दस्तावेजों को देख पाएंगे। एक नया दस्तावेज़ बनाने के लिए, पर क्लिक करेंInsertशीर्ष पर लिंक। आप दस्तावेज़ के डेटा को JSON या सरणी प्रारूप में दर्ज कर सकते हैं और उस पर क्लिक कर सकते हैंSave

निर्यात / आयात डेटा

किसी भी संग्रह के डेटा को आयात / निर्यात करने के लिए, उस संग्रह पर क्लिक करें और फिर पर क्लिक करें Export/Importशीर्ष पैनल पर लिंक। अपने डेटा को ज़िप प्रारूप में निर्यात करने के लिए अगले निर्देशों का पालन करें और फिर वापस डेटा आयात करने के लिए उसी ज़िप फ़ाइल को आयात करें।

GridFSबड़ी फ़ाइलों जैसे छवियों, ऑडियो फ़ाइलों, वीडियो फ़ाइलों आदि को संग्रहीत और पुनर्प्राप्त करने के लिए MongoDB विनिर्देशन है। यह फ़ाइलों को संग्रहीत करने के लिए एक फ़ाइल सिस्टम की तरह है, लेकिन इसका डेटा MongoDB संग्रह में संग्रहीत है। GridFS में 16MB की दस्तावेज़ आकार सीमा से अधिक फ़ाइलों को संग्रहीत करने की क्षमता है।

GridFS एक फ़ाइल को चंक्स में विभाजित करता है और डेटा के प्रत्येक भाग को एक अलग दस्तावेज़ में संग्रहीत करता है, प्रत्येक अधिकतम आकार 255k।

डिफ़ॉल्ट रूप से ग्रिड्स दो संग्रह का उपयोग करता है fs.files तथा fs.chunksफ़ाइल के मेटाडेटा और विखंडू को संग्रहीत करने के लिए। प्रत्येक ठग की पहचान उसके अनूठे _id ObjectId क्षेत्र से होती है। Fffiles एक मूल दस्तावेज के रूप में कार्य करता है। files_id fs.chunks दस्तावेज़ में फ़ील्ड अपने माता-पिता के लिए लिंक को जोड़ता है।

निम्नलिखित fffiles संग्रह का एक नमूना दस्तावेज है -

{
   "filename": "test.txt",
   "chunkSize": NumberInt(261120),
   "uploadDate": ISODate("2014-04-13T11:32:33.557Z"),
   "md5": "7b762939321e146569b07f72c62cca4f",
   "length": NumberInt(646)
}

दस्तावेज़ फ़ाइल नाम, चंक आकार, अपलोड की गई तिथि और लंबाई निर्दिष्ट करता है।

निम्नलिखित fs.chunks दस्तावेज़ का एक नमूना दस्तावेज़ है -

{
   "files_id": ObjectId("534a75d19f54bfec8a2fe44b"),
   "n": NumberInt(0),
   "data": "Mongo Binary Data"
}

ग्रिड में फ़ाइलें जोड़ना

अब, हम GridFS का उपयोग करके एक एमपी 3 फ़ाइल स्टोर करेंगे putआदेश। इसके लिए, हम इसका उपयोग करेंगेmongofiles.exe MongoDB स्थापना फ़ोल्डर के बिन फ़ोल्डर में मौजूद उपयोगिता।

अपना कमांड प्रॉम्प्ट खोलें, MongoDB स्थापना फ़ोल्डर के बिन फ़ोल्डर में mongofiles.exe पर जाएं और निम्न कोड टाइप करें -

>mongofiles.exe -d gridfs put song.mp3

यहाँ, gridfsउस डेटाबेस का नाम है जिसमें फ़ाइल संग्रहीत की जाएगी। यदि डेटाबेस मौजूद नहीं है, तो MongoDB स्वचालित रूप से मक्खी पर एक नया दस्तावेज़ बनाएगा। Song.mp3 अपलोड की गई फ़ाइल का नाम है। डेटाबेस में फ़ाइल का दस्तावेज़ देखने के लिए, आप क्वेरी का उपयोग कर सकते हैं -

>db.fs.files.find()

उपरोक्त कमांड ने निम्नलिखित दस्तावेज लौटाया -

{
   _id: ObjectId('534a811bf8b4aa4d33fdf94d'), 
   filename: "song.mp3", 
   chunkSize: 261120, 
   uploadDate: new Date(1397391643474), md5: "e4f53379c909f7bed2e9d631e15c1c41",
   length: 10401959 
}

हम पिछले कोड में लौटी डॉक्यूमेंट आईडी का उपयोग करते हुए, निम्न कोड के साथ संग्रहित फ़ाइल से संबंधित fs.chunks संग्रह में मौजूद सभी विखंडू भी देख सकते हैं -

>db.fs.chunks.find({files_id:ObjectId('534a811bf8b4aa4d33fdf94d')})

मेरे मामले में, क्वेरी ने 40 दस्तावेज़ लौटाए हैं जिसका अर्थ है कि पूरे एमपी दस्तावेज़ को डेटा के 40 भाग में विभाजित किया गया था।

Capped collectionsफिक्स्ड-आकार के परिपत्र संग्रह हैं जो ऑपरेशन बनाने, पढ़ने और हटाने के लिए उच्च प्रदर्शन का समर्थन करने के लिए सम्मिलन आदेश का पालन करते हैं। परिपत्र द्वारा, इसका मतलब है कि जब संग्रह के लिए आवंटित किया गया निश्चित आकार समाप्त हो जाता है, तो यह संग्रह में सबसे पुराना दस्तावेज़ को हटाए बिना कोई स्पष्ट आदेश प्रदान करना शुरू कर देगा।

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

कैप्ड कलेक्शन बनाना

कैप्ड कलेक्शन बनाने के लिए, हम सामान्य क्रिएक्लेक्शन कमांड का उपयोग करते हैं लेकिन साथ में capped विकल्प के रूप में true और बाइट्स में संग्रह के अधिकतम आकार को निर्दिष्ट करना।

>db.createCollection("cappedLogCollection",{capped:true,size:10000})

संग्रह आकार के अतिरिक्त, हम संग्रह का उपयोग करके दस्तावेजों की संख्या को सीमित भी कर सकते हैं max पैरामीटर -

>db.createCollection("cappedLogCollection",{capped:true,size:10000,max:1000})

यदि आप जांचना चाहते हैं कि कोई संग्रह छाया हुआ है या नहीं, तो निम्नलिखित का उपयोग करें isCapped कमांड -

>db.cappedLogCollection.isCapped()

यदि कोई मौजूदा संग्रह है जिसे आप कैप्ड में बदलने की योजना बना रहे हैं, तो आप इसे निम्न कोड के साथ कर सकते हैं -

>db.runCommand({"convertToCapped":"posts",size:10000})

यह कोड हमारे मौजूदा संग्रह को बदल देगा posts एक छाया हुआ संग्रह करने के लिए।

छाया हुआ छायाचित्र संग्रह

डिफ़ॉल्ट रूप से, कैप्ड संग्रह पर एक खोज क्वेरी सम्मिलन क्रम में परिणाम प्रदर्शित करेगी। लेकिन अगर आप चाहते हैं कि दस्तावेजों को रिवर्स ऑर्डर में प्राप्त किया जाए, तो उपयोग करेंsort निम्न कोड में दिखाया गया है -

>db.cappedLogCollection.find().sort({$natural:-1})

जानने के लायक कैप संग्रह के बारे में कुछ अन्य महत्वपूर्ण बिंदु हैं -

  • हम एक कैप्ड संग्रह से दस्तावेज़ नहीं हटा सकते हैं।

  • कैप्ड संग्रह में कोई डिफ़ॉल्ट इंडेक्स मौजूद नहीं हैं, यहां तक ​​कि _id फ़ील्ड पर भी नहीं।

  • एक नया दस्तावेज़ सम्मिलित करते समय, MongoDB को डिस्क पर नए दस्तावेज़ को समायोजित करने के लिए वास्तव में एक जगह की तलाश नहीं है। यह संग्रह की पूंछ पर नए दस्तावेज़ को नेत्रहीन रूप से सम्मिलित कर सकता है। यह बहुत तेजी से छायांकित संग्रह में सम्मिलित संचालन करता है।

  • इसी तरह, दस्तावेज़ पढ़ते समय MongoDB डिस्क पर मौजूद दस्तावेज़ों को उसी क्रम में लौटाता है। इससे रीड ऑपरेशन बहुत तेज हो जाता है।

MongoDB में SQL डेटाबेस की तरह आउट-ऑफ-द-बॉक्स ऑटो-इंक्रीमेंट कार्यक्षमता नहीं है। डिफ़ॉल्ट रूप से, यह के लिए 12-बाइट ObjectId का उपयोग करता है_idदस्तावेजों की विशिष्ट पहचान के लिए प्राथमिक कुंजी के रूप में फ़ील्ड। हालाँकि, ऐसे परिदृश्य हो सकते हैं जहां हम चाहते हैं कि _id फ़ील्ड में ObjectId के अलावा कुछ ऑटो-इन्क्रिम्ड वैल्यू हो।

चूंकि यह MongoDB में एक डिफ़ॉल्ट विशेषता नहीं है, इसलिए हम प्रोग्रामेटिक रूप से इस कार्यक्षमता का उपयोग करके प्राप्त करेंगे counters MongoDB प्रलेखन द्वारा सुझाए अनुसार संग्रह।

काउंटर कलेक्शन का उपयोग करना

निम्नलिखित को धयान मे रखते हुए productsदस्तावेज़। हम चाहते हैं कि _id क्षेत्र एauto-incremented integer sequence 1,2,3,4 से शुरू होकर n तक।

{
  "_id":1,
  "product_name": "Apple iPhone",
  "category": "mobiles"
}

इसके लिए a बनाएं counters संग्रह, जो सभी अनुक्रम क्षेत्रों के लिए अंतिम अनुक्रम मान का ट्रैक रखेगा।

>db.createCollection("counters")

अब, हम काउंटर्स कलेक्शन में निम्नलिखित दस्तावेज़ को सम्मिलित करेंगे productid इसकी कुंजी के रूप में -

{
  "_id":"productid",
  "sequence_value": 0
}

मैदान sequence_value अनुक्रम के अंतिम मूल्य का ट्रैक रखता है।

काउंटर अनुक्रम में इस अनुक्रम दस्तावेज़ को सम्मिलित करने के लिए निम्नलिखित कोड का उपयोग करें -

>db.counters.insert({_id:"productid",sequence_value:0})

जावास्क्रिप्ट फ़ंक्शन बनाना

अब, हम एक फंक्शन बनाएंगे getNextSequenceValueजो अनुक्रम नाम को अपने इनपुट के रूप में लेगा, अनुक्रम संख्या को 1 से बढ़ाएगा और अद्यतन अनुक्रम संख्या को वापस करेगा। हमारे मामले में, अनुक्रम नाम हैproductid

>function getNextSequenceValue(sequenceName){

   var sequenceDocument = db.counters.findAndModify({
      query:{_id: sequenceName },
      update: {$inc:{sequence_value:1}},
      new:true
   });
	
   return sequenceDocument.sequence_value;
}

जावास्क्रिप्ट फ़ंक्शन का उपयोग करना

अब हम नए दस्तावेज़ बनाते समय और दिए गए अनुक्रम मान को दस्तावेज़ के _s फ़ील्ड के रूप में निर्दिष्ट करते हुए फ़ंक्शन getNextSequenceValue का उपयोग करेंगे।

निम्नलिखित कोड का उपयोग करके दो नमूना दस्तावेज़ डालें -

>db.products.insert({
   "_id":getNextSequenceValue("productid"),
   "product_name":"Apple iPhone",
   "category":"mobiles"
})

>db.products.insert({
   "_id":getNextSequenceValue("productid"),
   "product_name":"Samsung S3",
   "category":"mobiles"
})

जैसा कि आप देख सकते हैं, हमने _Nid फ़ील्ड के लिए मान सेट करने के लिए getNextSequenceValue फ़ंक्शन का उपयोग किया है।

कार्यक्षमता को सत्यापित करने के लिए, हमें खोज आदेश का उपयोग करके दस्तावेज़ लाने हैं -

>db.products.find()

उपरोक्त क्वेरी में ऑटो-इन्क्रिमेटेड _id फ़ील्ड वाले निम्नलिखित दस्तावेज़ लौटे हैं -

{ "_id" : 1, "product_name" : "Apple iPhone", "category" : "mobiles"}

{ "_id" : 2, "product_name" : "Samsung S3", "category" : "mobiles" }