MongoDB गो ड्राइवर ट्यूटोरियल

UPD: ट्यूटोरियल रिलीज संस्करण के रिलीज के संबंध में अद्यतन किया गया है।

अच्छी खबर है! MongoDB के लिए आधिकारिक गो ड्राइवर जारी किया गया है ।
थोड़े विचार के साथ, मैंने स्वयं सामग्री लिखने के बजाय आधिकारिक mongoDB वेबसाइट से लेख का अनुवाद करने का फैसला किया (यह अनुवाद लेख से अलग है)।
यहाँ इस ट्यूटोरियल में क्या होगा:

• मोंगो-गो-ड्राइवर स्थापित करें
• मोंगो-गो-ड्राइवर का उपयोग करके मोंगोडीबी से कनेक्ट करें
• BSON वस्तुओं का उपयोग करना
• CRUD विधियों का उपयोग करना

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

मोंगो-गो-ड्राइवर स्थापित करें

यह अनुशंसा की जाती है कि आप ड्राइवर का उपयोग कर स्थापित करें (बेशक, यदि आप अभी भी मॉड्यूल पर स्विच नहीं कर रहे हैं):

dep ensure -add "go.mongodb.org/mongo-driver/mongo@~1.0.0" 

नींव का निर्माण

एक परियोजना बनाएं और निम्नलिखित सामग्री के साथ main.go फ़ाइल जोड़ें:

 package main import ( "context" "fmt" "log" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/options" "go.mongodb.org/mongo-driver/mongo/readpref" ) // You will be using this Trainer type later in the program type Trainer struct { Name string Age int City string } func main() { // Rest of the code will go here } 

इस कोड में, हम मोंगो-गो-ड्राइवर, कुछ मानक लाइब्रेरी आयात करते हैं, और ट्रेनर प्रकार को परिभाषित करते हैं।

Mongo-go-driver का उपयोग करके mongoDB से कनेक्ट करें

जब हमने mongo-go-driver को इम्पोर्ट किया, तो हमें mongo.NewClient () फ़ंक्शन का उपयोग करके mongoDB के लिए एक कनेक्शन बनाने का अवसर मिला। हमारे पास इस फ़ंक्शन को संदर्भ के रूप में पारित करने का अवसर है और मोंगोडब से कनेक्शन के पते वाले लाइन का तर्क है। यदि वांछित है, तो हम विकल्प को भी पास कर सकते हैं ।ientOptions ऑब्जेक्ट को ठीक-ठीक ड्राइवर पैरामीटर के लिए तीसरे तर्क के रूप में।
प्रलेखन उपलब्ध विकल्पों का विवरण देता है।

चलिए मुख्य फ़ंक्शन बॉडी में निम्नलिखित कोड जोड़ते हैं:

 // Create client client, err := mongo.NewClient(options.Client().ApplyURI("mongodb://127.0.0.1:27017")) if err != nil { log.Fatal(err) } // Create connect err = client.Connect(context.TODO()) if err != nil { log.Fatal(err) } // Check the connection err = client.Ping(context.TODO(), nil) if err != nil { log.Fatal(err) } fmt.Println("Connected to MongoDB!") 

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

 collection := client.Database("test").Collection("trainers") 

यह अनुशंसा की जाती है कि आप कनेक्शन को mongoDB के साथ खुला रखें ताकि आपको प्रत्येक अनुरोध के लिए कनेक्शन को खोलना और बंद न करना पड़े। हालाँकि, यदि एप्लिकेशन को अब कनेक्शन की आवश्यकता नहीं है, तो इसे क्लाइंट का उपयोग करके बंद किया जा सकता है। इस प्रकार से () फ़ंक्शन निम्नानुसार है:

 err = client.Disconnect(context.TODO()) if err != nil { log.Fatal(err) } fmt.Println("Connection to MongoDB closed.") 

अप्रयुक्त पैकेजों पर टिप्पणी करें।

MongoDB सर्वर से कनेक्शन की जांच करने के लिए हमारा कोड ( go run main.go ) चलाएं।

BSON वस्तुओं का उपयोग करना

MSONoDB में JSON दस्तावेज़ों को एक बाइनरी फॉर्मेट में संग्रहीत किया जाता है जिसे BSON कहा जाता है। अन्य डेटाबेसों के विपरीत, जिसमें JSON डेटा को स्ट्रिंग्स और संख्याओं के रूप में संग्रहीत किया जाता है, BSON एन्कोडिंग नए प्रकार जोड़ता है, जैसे int , long , date , float और दशमलव128 ।

यह अनुप्रयोगों द्वारा डेटा के प्रसंस्करण, छंटाई और तुलना को बहुत सरल करता है। Go ड्राइवर में BSON डेटा का प्रतिनिधित्व करने के लिए दो प्रकार के परिवार हैं: D प्रकार और RAW प्रकार।

परिवार डी चार प्रकार के होते हैं:

• D : BSON दस्तावेज़। इस प्रकार का उपयोग उन स्थितियों में किया जाना चाहिए जहां ऑर्डर मायने रखता है, उदाहरण के लिए, MongoDB कमांड।
• एम : अनियंत्रित शब्दकोश (साहचर्य सरणी, नक्शा)। यह डी के समान है, सिवाय इसके कि यह आदेश को संरक्षित नहीं करता है।
• एक : BSON सरणी।
• ई : डी के अंदर एकल तत्व ।

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

कच्चे प्रकार के परिवार का उपयोग बाइट टुकड़ा करने के लिए किया जाता है। आप लुकअप () का उपयोग करके रॉ प्रकार से एकल तत्व निकाल सकते हैं।

यह तब उपयोगी हो सकता है जब आपको BSON को किसी अन्य प्रकार में परिवर्तित करते समय अतिरिक्त भार से छुटकारा पाने की आवश्यकता होती है।
इस ट्यूटोरियल में केवल डी-टाइप परिवार का उपयोग किया जाएगा।

CRUD विधियों का उपयोग करना

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

दस्तावेजों का सम्मिलन (निर्माण)

पहले आपको डेटाबेस में सम्मिलित करने के लिए कुछ नई ट्रेनर संरचनाएँ बनाने की आवश्यकता है:

 ash := Trainer{"Ash", 10, "Pallet Town"} misty := Trainer{"Misty", 10, "Cerulean City"} brock := Trainer{"Brock", 15, "Pewter City"} 

किसी एकल दस्तावेज़ को एम्बेड करने के लिए, संग्रह का उपयोग करें। InsertOne () विधि:

 insertResult, err := collection.InsertOne(context.TODO(), ash) if err != nil { log.Fatal(err) } fmt.Println("Inserted a single document: ", insertResult.InsertedID) 

एक ही समय में एक से अधिक दस्तावेज़ सम्मिलित करने के लिए, संग्रह । InertMany () विधि मौजूद है:

 trainers := []interface{}{misty, brock} insertManyResult, err := collection.InsertMany(context.TODO(), trainers) if err != nil { log.Fatal(err) } fmt.Println("Inserted multiple documents: ", insertManyResult.InsertedIDs) 

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

संग्रह . UpdateOne () विधि आपको एक दस्तावेज़ को अपडेट करने की अनुमति देती है। आपको डेटाबेस में एक दस्तावेज़ और अपडेट ऑपरेशन के लिए एक दस्तावेज़ खोजने के लिए एक फ़िल्टर बनाने की आवश्यकता है। आप उन्हें bson.D प्रकार का उपयोग करके बना सकते हैं:

 filter := bson.D{{"name", "Ash"}} update := bson.D{ {"$inc", bson.D{ {"age", 1}, }}, } 

निम्नलिखित कोड में एक दस्तावेज़ मिलेगा जिसमें नाम फ़ील्ड ऐश के मूल्य से मेल खाता है और 1 से उम्र के मूल्य को बढ़ाता है।

 updateResult, err := collection.UpdateOne(context.TODO(), filter, update) if err != nil { log.Fatal(err) } fmt.Printf("Matched %v documents and updated %v documents.\n", updateResult.MatchedCount, updateResult.ModifiedCount) 

दस्तावेज़ खोज

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

एक एकल दस्तावेज़ खोजने के लिए, संग्रह का उपयोग करें ।indOne () । यह विधि एक एकल मान लौटाती है जिसे एक चर में डीकोड किया जा सकता है।

हम उसी फ़िल्टर चर का उपयोग करेंगे जिसका उपयोग अद्यतन अनुरोध में किया गया था।

 // create a value into which the result can be decoded var result Trainer err = collection.FindOne(context.TODO(), filter).Decode(&result) if err != nil { log.Fatal(err) } fmt.Printf("Found a single document: %+v\n", result) 

कई दस्तावेज खोजने के लिए, संग्रह का उपयोग करें। हिंद () ।

यह विधि Cursor लौटाती है। Cursor दस्तावेजों की एक धारा प्रदान करता है जिसके साथ आप एक बार में एक दस्तावेज़ को पुन: व्यवस्थित और डीकोड कर सकते हैं।

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

हमारे उदाहरण में, हमने दो दस्तावेजों को जारी करने की सीमा निर्धारित की है।

 // Pass these options to the Find method options := options.Find() options.SetLimit(2) filter := bson.M{} // Here's an array in which you can store the decoded documents var results []*Trainer // Passing nil as the filter matches all documents in the collection cur, err := collection.Find(context.TODO(), filter, options) if err != nil { log.Fatal(err) } // Finding multiple documents returns a cursor // Iterating through the cursor allows us to decode documents one at a time for cur.Next(context.TODO()) { // create a value into which the single document can be decoded var elem Trainer err := cur.Decode(&elem) if err != nil { log.Fatal(err) } results = append(results, &elem) } if err := cur.Err(); err != nil { log.Fatal(err) } // Close the cursor once finished cur.Close(context.TODO()) fmt.Printf("Found multiple documents (array of pointers): %+v\n", results) 

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

आप collection.DeleteOne () या collection.DeleteMany () का उपयोग करके दस्तावेज़ों को हटा सकते हैं। हम फ़िल्टर तर्क के रूप में एनआईएल पास करते हैं, जो संग्रह में सभी दस्तावेजों से मेल खाएगा। आप संपूर्ण संग्रह को हटाने के लिए collection.Drop () का भी उपयोग कर सकते हैं।

 filter := bson.M{} deleteResult, err := collection.DeleteMany(context.TODO(), filter) if err != nil { log.Fatal(err) } fmt.Printf("Deleted %v documents in the trainers collection\n", deleteResult.DeletedCount) 

आगे के कदम

→ इस ट्यूटोरियल का अंतिम कोड GitHub रिपॉजिटरी में है
→ GoDoc में उपलब्ध ड्राइवर प्रलेखन

यदि आपके कोई प्रश्न हैं, तो कृपया हमसे Google समूह mongo-go-driver में संपर्क करें।
कृपया MongoDB JIRA को बग रिपोर्ट भेजें।
हमें Go Driver के बारे में आपकी प्रतिक्रिया प्राप्त करने में खुशी होगी।