MongoDB डेटा प्रकारों का परिचय

परिचय

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

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

JSON और BSON

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

डेटा स्टोर करने के लिए JSON का उपयोग करने के कई फायदे हैं। उनमें से कुछ हैं:

• डेवलपर्स के बीच पढ़ने, सीखने और इसकी परिचितता में आसानी
• प्रारूप में लचीलापन, चाहे विरल, पदानुक्रमित, या गहरा घोंसला हो
• स्व-वर्णन, जो अनुप्रयोगों को JSON डेटा के साथ आसानी से संचालित करने की अनुमति देता है
• न्यूनतम प्रकार के बुनियादी प्रकारों पर ध्यान केंद्रित करने की अनुमति देता है

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

MongoDB में डेटा प्रकार क्या हैं?

विस्तार में जाने से पहले, आइए देखें कि MongoDB में कौन से डेटा प्रकार समर्थित हैं।

MongoDB सरल और जटिल दोनों प्रकार के डेटा के विभिन्न प्रकारों के लिए उपयुक्त डेटा प्रकारों की एक श्रृंखला का समर्थन करता है। इनमें शामिल हैं:

टेक्स्ट

• String

संख्यात्मक

• 32-Bit Integer
• 64-Bit Integer
• Double
• Decimal128

दिनांक/समय

• Date
• Timestamp

अन्य

• Object
• Array
• Binary Data
• ObjectId
• Boolean
• Null
• Regular Expression
• JavaScript
• Min Key
• Max Key

MongoDB में, प्रत्येक BSON प्रकार में पूर्णांक और स्ट्रिंग पहचानकर्ता दोनों होते हैं। हम इस गाइड में इनमें से सबसे सामान्य को अधिक गहराई से कवर करेंगे।

स्ट्रिंग प्रकार

स्ट्रिंग प्रकार सबसे अधिक इस्तेमाल किया जाने वाला MongoDB डेटा प्रकार है। दोहरे उद्धरण चिह्नों के अंदर लिखा गया कोई भी मान "" JSON में एक स्ट्रिंग मान है। कोई भी मान जिसे आप टेक्स्ट के रूप में संग्रहीत करना चाहते हैं, उसे String . के रूप में सबसे अच्छा टाइप किया जाएगा . बीएसओएन स्ट्रिंग्स यूटीएफ -8 हैं और मोंगोडीबी में इस प्रकार प्रदर्शित होते हैं:

        Type         | Number |  Alias   |  ------------------ | ------ | -------- |       String        |    2   | "string" |
 

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

String with के साथ दस्तावेज़ सम्मिलित करना डेटा प्रकार कुछ इस तरह दिखेगा:

db.mytestcoll.insertOne({first_name: "Alex"}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d15")}
 

संग्रह को क्वेरी करने से निम्नलिखित वापस आ जाएगा:

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d15"),         first_name: "Alex"}
 

$type का उपयोग करना ऑपरेटर

हमारे अगले डेटा प्रकार पर जाने से पहले, यह जानना महत्वपूर्ण है कि आप कोई प्रविष्टि करने से पहले मूल्य की जांच कैसे कर सकते हैं। हम $type . का उपयोग करके प्रदर्शित करने के लिए पिछले उदाहरण का उपयोग करेंगे MongoDB में ऑपरेटर।

मान लें कि हमें mytestcoll . के साथ काम करते हुए कुछ समय हो गया है पहले से संग्रह। हम संग्रह में first_name . के साथ कुछ अतिरिक्त दस्तावेज़ सम्मिलित करना चाहते हैं खेत। यह जांचने के लिए कि हमने String . का उपयोग किया है first_name . के मान के रूप में संग्रहीत डेटा प्रकार के रूप में मूल रूप से, हम डेटा प्रकार के उपनाम या संख्या मान का उपयोग करके निम्नलिखित को चला सकते हैं:

db.mytestcoll.find( { "first_name": { $type: "string" } } )
 

या

db.mytestcoll.find( { "first_name": { $type: 2 } } )
 

दोनों क्वेरीज़ उन सभी दस्तावेज़ों का आउटपुट लौटाती हैं जिनमें String . होता है first_name . के लिए संग्रहीत मान हमारे पिछले अनुभाग के सम्मिलन से:

[ { _id: ObjectId("614b37296a124db40ae74d15"), first_name: "Alex" } ]
 

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

आप $type . के साथ एक बार में अनेक डेटा प्रकारों के लिए क्वेरी करने में सक्षम हैं निम्नलिखित की तरह ऑपरेटर:

db.mytestcoll.find( { "first_name": { $type: ["string", "null"] } } )
 

क्योंकि हमने कोई Null नहीं डाला है हमारे संग्रह में मान टाइप करें, परिणाम वही होगा:

[ { _id: ObjectId("614b37296a124db40ae74d15"), first_name: "Alex" } ]
 

आप निम्न सभी प्रकारों के साथ उसी विधि का उपयोग कर सकते हैं, जिस पर हम चर्चा करेंगे।

संख्याएं और संख्यात्मक मान

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

पूर्णांक

Integer डेटा प्रकार का उपयोग संख्याओं को बिना किसी भिन्न या दशमलव के पूर्ण संख्याओं के रूप में संग्रहीत करने के लिए किया जाता है। पूर्णांक या तो सकारात्मक या नकारात्मक मान हो सकते हैं। MongoDB में दो प्रकार होते हैं, 32-Bit Integer और 64-Bit Integer . उन्हें नीचे दी गई तालिका में दो तरह से दर्शाया जा सकता है, number और alias :

  Integer type   | number |    alias     |   ------------   | -----  | ------------ |  `32-bit integer`|   16   |    "int"     | `64-bit integer`|   18   |    "long"    |
 

प्रत्येक प्रकार के लिए एक मान में फिट होने वाली श्रेणियां निम्नलिखित हैं:

  Integer type   |    Applicable signed range     |    Applicable unsigned range    |  ------------   | ------------------------------ | ------------------------------- | `32-bit integer`| -2,147,483,648 to 2,147,483,647|  0 to 4,294,967,295             | `64-bit integer`| -9,223,372,036,854,775,808 to  |  0 to 18,446,744,073,709,551,615                         9,223,372,036,854,775,807
 

उपरोक्त प्रकार उनकी मान्य सीमा द्वारा सीमित हैं। सीमा के बाहर किसी भी मान के परिणामस्वरूप त्रुटि होगी। एक Integer प्रविष्ट करना MongoDB में टाइप करें नीचे जैसा दिखेगा:

db.mytestcoll.insertOne({age: 26}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d14")}
 

और परिणाम खोजने से निम्नलिखित वापस आ जाएगा:

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d14"), age: 26}
 

जैसा कि नामों से पता चलता है, एक 32-Bit Integer पूर्णांक परिशुद्धता के 32 बिट हैं जो छोटे पूर्णांक मानों के लिए उपयोगी है जिन्हें आप अंकों के अनुक्रम के रूप में संग्रहीत नहीं करना चाहते हैं। संख्या आकार में बढ़ने पर, आप 64-Bit Integer . तक पहुंचने में सक्षम होते हैं जिसमें 64 बिट पूर्णांक परिशुद्धता है और पूर्व के समान उपयोग के मामले में फिट बैठता है।

डबल

BSON में, JSON की संख्या . के लिए डिफ़ॉल्ट प्रतिस्थापन Double है डेटा प्रकार। Double डेटा प्रकार का उपयोग फ़्लोटिंग-पॉइंट मान को संग्रहीत करने के लिए किया जाता है और इसे MongoDB में इस प्रकार दर्शाया जा सकता है:

        Type         | Number |   Alias  |  ------------------ | ------ | -------- |       Double        |    1   | "double" |
 

फ़्लोटिंग पॉइंट नंबर दशमलव संख्याओं को व्यक्त करने का एक और तरीका है, लेकिन सटीक, लगातार सटीकता के बिना।

फ़्लोटिंग पॉइंट नंबर बड़ी संख्या में दशमलव के साथ कुशलता से काम कर सकते हैं लेकिन हमेशा बिल्कुल नहीं। Double . के साथ दस्तावेज़ दर्ज करने का एक उदाहरण निम्नलिखित है अपने संग्रह में टाइप करें:

db.mytestcoll.insertOne({testScore: 89.6}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d13")}
 

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

Decimal128

यदि आप बहुत बड़ी संख्या में फ्लोटिंग पॉइंट रेंज के साथ काम कर रहे हैं, तो Decimal128 बीएसओएन डेटा प्रकार सबसे अच्छा विकल्प होगा। यह उन मूल्यों के लिए सबसे उपयोगी प्रकार होगा जिनके लिए बहुत अधिक सटीकता की आवश्यकता होती है जैसे सटीक मौद्रिक संचालन से जुड़े मामलों का उपयोग करना। Decimal128 प्रकार को इस प्रकार दर्शाया गया है:

        Type         | Number |   Alias   |  ------------------ | ------ | --------- |      Decimal128     |   19   | "decimal" |
 

बीएसओएन प्रकार, Decimal128 , संख्याओं को संग्रहीत करने के लिए दशमलव प्रतिनिधित्व के 128 बिट्स प्रदान करता है जहां दशमलव को गोल करना वास्तव में महत्वपूर्ण है। Decimal128 6143 से +6144 की सीमा के साथ 34 दशमलव अंकों की सटीकता, या एक पापी और का समर्थन करता है। यह उच्च मात्रा में सटीकता की अनुमति देता है।

Decimal128 . का उपयोग करके कोई मान प्रविष्ट करना डेटा प्रकार के लिए NumberDecimal() . का उपयोग करना आवश्यक है कंस्ट्रक्टर आपके नंबर के साथ String . के रूप में MongoDB को डिफ़ॉल्ट संख्यात्मक प्रकार का उपयोग करने से रोकने के लिए, Double .

यहां, हम इसे प्रदर्शित करते हैं:

db.mytestcoll.insertOne({price : NumberDecimal("5.099")}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d12")}
 

संग्रह की क्वेरी करते समय, आपको निम्नलिखित रिटर्न मिलता है:

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d12"),         price: "5.099" }
 

संख्यात्मक मान सटीक संचालन के लिए इसकी सटीकता को बनाए रखता है। Decimal128 प्रदर्शित करने के लिए टाइप बनाम Double , हम निम्नलिखित अभ्यास से गुजर सकते हैं।

डेटा प्रकार के आधार पर सटीकता को कैसे खोया जा सकता है

मान लें कि हम कई दशमलव मानों वाली एक संख्या को Double . के रूप में सम्मिलित करना चाहते हैं निम्नलिखित के साथ MongoDB में:

db.mytestcoll.insertOne({ price: 9999999.4999999999 }){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d24")}
 

जब हम इस डेटा के लिए क्वेरी करते हैं, तो हमें निम्नलिखित परिणाम मिलते हैं:

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d24"),         price: 9999999.5}
 

यह मान 9999999.5 . तक होता है , इसका सटीक मान खो रहा है जिसके साथ हमने इसे इनपुट किया है। यह Double बनाता है कई दशमलव वाली संख्याओं के संग्रहण के लिए अनुपयुक्त है।

अगला उदाहरण दर्शाता है कि Double . पास करते समय सटीकता कहां खो जाएगी परोक्ष रूप से Decimal128 . के साथ String . के बजाय पिछले उदाहरण की तरह।

हम निम्नलिखित Double डालने से प्रारंभ करते हैं फिर से लेकिन NumberDecimal() . के साथ इसे Decimal128 बनाने के लिए टाइप करें:

db.mytestcoll.insertOne({ price: NumberDecimal( 9999999.4999999999 ) }){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d14")}
 

नोट :इस प्रविष्टि को MongoDB शेल में करते समय, निम्न चेतावनी संदेश प्रदर्शित होता है:

Warning: NumberDecimal: specifying a number as argument is deprecated and may lead to loss of precision, pass a string instead
 

यह चेतावनी संदेश इंगित करता है कि जिस नंबर को आप पास करने का प्रयास कर रहे हैं वह सटीकता के नुकसान के अधीन हो सकता है। वे String . का उपयोग करने का सुझाव देते हैं NumberDecimal() . का उपयोग करके ताकि आप कोई सटीकता न खोएं।

यदि हम किसी भी तरह से चेतावनी को अनदेखा करते हैं और दस्तावेज़ को सम्मिलित करते हैं, तो मूल्य के पूर्णांकन से क्वेरी परिणामों में सटीकता का नुकसान देखा जाता है:

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d14"),         price: Decimal128("9999999.50000000")}
 

अगर हम सुझाए गए NumberDecimal() . का पालन करते हैं String . का उपयोग करके दृष्टिकोण हम निम्न परिणामों को सटीक बनाए रखने के साथ देखेंगे:

db.mytestcoll.insertOne({ price: NumberDecimal( "9999999.4999999999" ) } )
 

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d14"),         price: Decimal128("9999999.4999999999")}
 

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

तारीख

बीएसओएन Date डेटा प्रकार एक 64-बिट पूर्णांक है जो यूनिक्स युग (1 जनवरी, 1970) के बाद से मिलीसेकंड की संख्या का प्रतिनिधित्व करता है। यह डेटा प्रकार वर्तमान दिनांक या समय को संग्रहीत करता है और इसे दिनांक ऑब्जेक्ट या स्ट्रिंग के रूप में वापस किया जा सकता है। Date MongoDB में इस प्रकार दर्शाया गया है:

        Type         | Number |     Alias    |  ------------------ | ------ | ------------ |        Date         |    9   |     "date"   |
 

नोट :बीएसओएन Date प्रकार हस्ताक्षरित है। नकारात्मक मान 1970 से पहले की तारीखों को दर्शाते हैं।

दिनांक मान वापस करने के तीन तरीके हैं।

1. Date() - एक स्ट्रिंग देता है

2. new Date() - ISODate() . का उपयोग करके दिनांक वस्तु लौटाता है आवरण

3. ISODate() - ISODate() . का उपयोग करके दिनांक वस्तु भी लौटाता है आवरण

हम इन विकल्पों को नीचे प्रदर्शित करते हैं:

var date1 = Date()var date2 = new Date()var date3 = ISODate()db.mytestcoll.insertOne({firstDate: date1, secondDate: date2, thirdDate: date3}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d22")}
 

और लौटते समय:

db.mytestcoll.find().pretty(){                "_id" : ObjectId("614b37296a124db40ae74d22"),                firstDate: 'Tue Sep 28 2021 11:28:52 GMT+0200 (Central European Summer Time)',                secondDate: ISODate("2021-09-28T09:29:01.924Z"),                thirdDate: ISODate("2021-09-28T09:29:12.151Z")}
 

टाइमस्टैम्प

Timestamp भी है समय का प्रतिनिधित्व करने के लिए MongoDB में डेटा प्रकार। हालांकि, Timestamp आंतरिक उपयोग के लिए सबसे उपयोगी होने जा रहा है और नहीं Date . के साथ संबद्ध प्रकार। प्रकार ही वर्णों का एक क्रम है जिसका उपयोग किसी घटना के घटित होने की तिथि और समय का वर्णन करने के लिए किया जाता है। Timestamp एक 64 बिट मान है जहां:

• सबसे महत्वपूर्ण 32 बिट हैं time_t मान (यूनिक्स युग के बाद से सेकंड)
• कम से कम महत्वपूर्ण 32 बिट एक इंक्रीमेंटिंग ordinal हैं एक निश्चित सेकंड के भीतर संचालन के लिए

MongoDB में इसका प्रतिनिधित्व इस प्रकार दिखेगा:

        Type         | Number |     Alias    |  ------------------ | ------ | ------------ |      Timestamp      |   17   |  "timestamp" |
 

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

एक नया Timestamp सम्मिलित करना MongoDB में मान new Timestamp() . का उपयोग करेगा कार्य करें और कुछ इस तरह दिखें:

db.mytestcoll.insertOne( {ts: new Timestamp() });{        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d23")}
 

संग्रह की क्वेरी करते समय, आप एक जैसा परिणाम देंगे:

db.mytestcoll.find().pretty(){        "_id" : ObjectId("614b37296a124db40ae74d24"),         "ts" : Timestamp( { t: 1412180887, i: 1 })}
 

ऑब्जेक्ट

Object MongoDB में डेटा प्रकार का उपयोग एम्बेडेड दस्तावेज़ों को संग्रहीत करने के लिए किया जाता है। एम्बेडेड दस्तावेज़ key: value . में नेस्टेड दस्तावेज़ों की एक श्रृंखला है जोड़ी प्रारूप। हम Object . प्रदर्शित करते हैं नीचे टाइप करें:

var classGrades = {"Physics": 88, "German": 92, "LitTheoery": 79}db.mytestcoll.insertOne({student_name: "John Smith", report_card: classGrades}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d18")}
 

फिर हम अपना नया दस्तावेज़ देख सकते हैं:

db.mytestcoll.find().pretty(){    _id: ObjectId("614b37296a124db40ae74d18"),    student_name: 'John Smith',    report_card: {Physics: 88, German: 92, LitTheoery: 79}}
 

Object डेटा प्रकार उस डेटा को संग्रहीत करने के लिए अनुकूलित करता है जिसे एक साथ सर्वोत्तम रूप से एक्सेस किया जाता है। उपरोक्त उदाहरण से, प्रत्येक वर्ग चिह्न को अलग से संग्रहीत करने के विपरीत, यह भंडारण, गति और स्थायित्व के आसपास कुछ क्षमताएं प्रदान करता है।

बाइनरी डेटा

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

        Type         | Number |     Alias    |  ------------------ | ------ | ------------ |      Binary data    |    5   |   "binData"  |
 

यहां कुछ Binary Data जोड़ने का एक उदाहरण दिया गया है संग्रह में एक दस्तावेज़ में:

var data = BinData(1, "111010110111100110100010101")db.mytestcoll.insertOne({binaryData: data}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d20")}
 

फिर परिणामी दस्तावेज़ देखें:

db.mytestcoll.find().pretty(){        "_id" : ObjectId("614b37296a124db40ae74d20"),        "binaryData" : BinData(1, "111010110111100110100010101")}
 

ObjectId

ObjectId प्रकार MongoDB के लिए विशिष्ट है और यह दस्तावेज़ की विशिष्ट आईडी संग्रहीत करता है। MongoDB एक _id प्रदान करता है प्रत्येक दस्तावेज़ के लिए फ़ील्ड। ObjectId आकार में 12 बाइट्स है और इसे निम्नानुसार दर्शाया जा सकता है:

        Type         | Number |     Alias    |  ------------------ | ------ | ------------ |      ObjectId       |    7   |   "objectId" |
 

ObjectId में तीन भाग होते हैं जो इसके 12-बाइट मेकअप को बनाते हैं:

• एक 4-बाइट टाइमस्टैम्प मान , ObjectId के निर्माण का प्रतिनिधित्व करता है, जिसे यूनिक्स युग के बाद से सेकंड में मापा जाता है
• एक 5-बाइट यादृच्छिक मान
• एक 3-बाइट इन्क्रीमेंटिंग काउंटर एक यादृच्छिक मान के लिए प्रारंभ किया गया

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

_id . के लिए ObjectIds का उपयोग करने के कई लाभ हैं :

• mongoshमें (MongoDB शेल), ObjectId . का निर्माण समय ObjectId.getTimestamp() . का उपयोग करके पहुँचा जा सकता है विधि।
• एक _id पर छांटना फ़ील्ड जो ObjectId . स्टोर करती है डेटा प्रकार सृजन समय के आधार पर छँटाई के समान है।

हमने अब तक सभी उदाहरणों में ObjectIds देखे हैं, और वे इसके समान दिखाई देंगे:

db.mytestcoll.find().pretty(){         _id: ObjectId("614b37296a124db40ae74d19")}
 

नोट :ObjectId मान समय के साथ बढ़ना चाहिए, हालांकि वे जरूरी नहीं कि मोनोटोनिक हों। ऐसा इसलिए है क्योंकि वे:

• अस्थायी समाधान का केवल एक सेकंड होता है, इसलिए उसी सेकंड के भीतर बनाए गए मानों में गारंटीकृत आदेश नहीं होता है
• मान क्लाइंट द्वारा जेनरेट किए जाते हैं, जिनकी सिस्टम क्लॉक भिन्न हो सकती हैं

बूलियन

MongoDB का मूल Boolean है संग्रह के भीतर सही और गलत मानों को संग्रहीत करने के लिए डेटा प्रकार। Boolean MongoDB में निम्नानुसार दर्शाया जा सकता है:

        Type         | Number |     Alias    |  ------------------ | ------ | ------------ |       Boolean       |    8   |     "bool"   |
 

Boolean . के साथ दस्तावेज़ सम्मिलित करना डेटा प्रकार कुछ इस तरह दिखेगा:

db.mytestcoll.insertOne({isCorrect: true, isIncorrect: false}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d21")}
 

फिर दस्तावेज़ की खोज करते समय परिणाम इस प्रकार दिखाई देगा:

db.mytestcoll.find().pretty(){    "_id" : ObjectId("614b37296a124db40ae74d21")    "isCorrect" : true,    "isIncorrect" : false}
 

रेगुलर एक्सप्रेशन

Regular Expression MongoDB में डेटा प्रकार एक क्षेत्र के मूल्य के रूप में नियमित अभिव्यक्तियों के भंडारण की अनुमति देता है। MongoDB अपनी नियमित अभिव्यक्ति भाषा के रूप में PCRE (पर्ल कम्पेटिबल रेगुलर एक्सप्रेशन) का उपयोग करता है।

इसे निम्नलिखित तरीके से दर्शाया जा सकता है:

        Type         | Number |  Alias  |  ------------------ | ------ | ------- |  Regular Expression |   11   | "regex" |
 

बीएसओएन आपको विशिष्ट "कन्वर्ट फ्रॉम स्ट्रिंग" चरण से बचने की अनुमति देता है जो आमतौर पर नियमित अभिव्यक्तियों और डेटाबेस के साथ काम करते समय अनुभव किया जाता है। यह प्रकार सबसे उपयोगी होगा जब आप डेटाबेस ऑब्जेक्ट लिख रहे हैं जिसके लिए सत्यापन पैटर्न या मिलान ट्रिगर्स की आवश्यकता होती है।

उदाहरण के लिए, आप Regular Expression को सम्मिलित कर सकते हैं डेटा प्रकार इस तरह:

db.mytestcoll.insertOne({exampleregex: /tt/}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d16")}db.mytestcoll.insertOne({exampleregext:/t+/}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d17")}
 

बयानों का यह क्रम इन दस्तावेजों को आपके संग्रह में जोड़ देगा। फिर आप सम्मिलित दस्तावेज़ों को खोजने के लिए अपने संग्रह को क्वेरी करने में सक्षम हैं:

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d16"), exampleregex: /tt/,        _id: ObjectId("614b37296a124db40ae74d17"), exampleregex: /t+/ }
 

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

JavaScript (बिना दायरे के)

काफी हद तक पहले बताए गए Regular Expression की तरह डेटा प्रकार, बीएसओएन मोंगोडीबी को अपने स्वयं के प्रकार के रूप में दायरे के बिना जावास्क्रिप्ट कार्यों को स्टोर करने की अनुमति देता है। JavaScript प्रकार को इस प्रकार पहचाना जा सकता है:

        Type         | Number |     Alias    |  ------------------ | ------ | ------------ |      JavaScript     |   13   | "javascript" |
 

JavaScript . के साथ अपने संग्रह में दस्तावेज़ जोड़ना डेटा प्रकार कुछ इस तरह दिखेगा:

db.mytestcoll.insertOne({jsCode: "function(){var x; x=1}"}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d122")}
 

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

नोट :MongoDB संस्करण 4.4 और इसके बाद के संस्करण के साथ, एक वैकल्पिक जावास्क्रिप्ट प्रकार, JavaScript with Scope डेटा प्रकार, बहिष्कृत कर दिया गया है

निष्कर्ष

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

यह जानना महत्वपूर्ण है कि डेटाबेस का उपयोग करते समय आपके लिए कौन से डेटा प्रकार उपलब्ध हैं ताकि आप मान्य मानों का उपयोग कर रहे हों और अपेक्षित परिणामों के साथ डेटा पर काम कर रहे हों। ऐसे जोखिम हैं जिनका सामना आप अपने डेटा को ठीक से टाइप किए बिना कर सकते हैं जैसे कि Double . में दिखाया गया है बनाम Decimal128 व्यायाम। किसी दिए गए प्रकार के लिए प्रतिबद्ध होने से पहले इसके बारे में सोचना महत्वपूर्ण है।

यदि आप मोंगोडीबी डेटाबेस के साथ प्रिज्मा की जांच करने में रुचि रखते हैं, तो आप डेटा कनेक्टर दस्तावेज़ीकरण देख सकते हैं।