मार्च 2019 में MongoDB के लिए आधिकारिक, उत्पादन के लिए तैयार GO ड्राइवर जारी किया गया था और इसे इसके लॉन्च से लगातार अपडेट मिल रहे हैं। इस ट्यूटोरियल में, हम गो ड्राइवर का उपयोग करके सरल MongoDB CRUD संचालन करना सीखेंगे।
आवश्यकताएं
इस ट्यूटोरियल को शुरू करने से पहले दो चीजों की आवश्यकता है।
- गो आपकी मशीन पर इंस्टाल होना चाहिए। इस ट्यूटोरियल के लिए गो संस्करण 1.15 का उपयोग किया जाता है। आप इस लिंक से गो पैकेज डाउनलोड कर सकते हैं।
- अपनी मशीन पर MongoDB का नवीनतम संस्करण स्थापित करें और MongoDB का स्थानीय सर्वर प्रारंभ करें।
MongoDB ड्राइवर की स्थापना
निम्न आदेश चलाकर MongoDB गो ड्राइवर स्थापित करें:
go get go.mongodb.org/mongo-driverयदि आप गो मॉड्यूल का उपयोग कर रहे हैं तो एक go.mod फ़ाइल बनाएं और फिर उपरोक्त आदेश मॉड फ़ाइल में आवश्यक निर्भरता जोड़ देगा। यह फ़ाइल सभी प्रोजेक्ट आवश्यकताओं को इसके सही संस्करण में लॉक कर देती है।
मुख्य फ़ाइल सेट करना
अपने प्रोजेक्ट फोल्डर में main.go फाइल बनाएं और इसे अपने आईडीई में खोलें। इससे पहले कि हम MongoDB संचालन के लिए कोड लिखें, आइए फ़ाइल में सभी आवश्यक पैकेज आयात करें।
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"
)अब, निम्नलिखित वैश्विक चर बनाएं जिनका उपयोग हम सभी CRUD संचालन कार्यों में करेंगे।
var client *mongo.Client
var collection *mongo.Collection
var ctx = context.TODO()इसके अलावा, दस्तावेज़ प्रकार के लिए संरचना बनाएं।
type Person struct {
Name string
Age int
City string
}MongoDB से कनेक्ट हो रहा है
अब बेस सेटअप तैयार है। आइए MongoDB से जुड़ने के लिए अपना पहला फ़ंक्शन बनाएं।
func connect() *mongo.Client {
clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
client, err := mongo.Connect(ctx, clientOptions)
if err != nil {
log.Fatal(err)
}
err = client.Ping(ctx, nil)
if err != nil {
log.Fatal(err)
}
fmt.Println("Connected to MongoDB!")
return client
}यह फ़ंक्शन हमारे स्थानीय रूप से चल रहे MongoDB के साथ कनेक्शन स्थापित करेगा और क्लाइंट ऑब्जेक्ट लौटाएगा। एक बार जब कनेक्ट विधि क्लाइंट ऑब्जेक्ट लौटाती है, तो हम यह जांचने के लिए पिंग () विधि का उपयोग कर सकते हैं कि कनेक्शन सफल था या नहीं। यदि पिंग () विधि कोई त्रुटि लौटाती है, तो हम त्रुटि को बढ़ा सकते हैं और वापस कर सकते हैं।
ऑपरेशन सम्मिलित करें
केवल एक दस्तावेज़ सम्मिलित करने के लिए, हम insertOne विधि का उपयोग कर सकते हैं और एक साथ कई दस्तावेज़ सम्मिलित करने के लिए, हम insertMany विधि का उपयोग कर सकते हैं। व्यक्ति संग्रह में एक दस्तावेज़ डालने का कार्य निम्नलिखित है:
func insertOne() {
akash := Person{"Akash", 28, "Bengaluru"}
res, err := collection. InsertOne (ctx, akash)
if err != nil {
log.Fatal(err)
}
fmt.Println("Inserted document: ", res.InsertedID)
}संग्रह में अनेक दस्तावेज़ जोड़ने का कार्य यहां दिया गया है:
func insertMany() {
akash := Person{"Akash", 28, "Bengaluru"}
bob := Person {"Bob", 30, "New York"}
robin := Person {"Robin", 25, "London"}
persons := []interface{}{akash, bob, robin}
res, err := collection.InsertMany(ctx, persons)
if err != nil {
log.Fatal(err)
}
fmt.Println("Inserted documents: ", res.InsertedIDs)
}दोनों परिचालनों के लिए, हमें उस व्यक्ति संरचना का उपयोग करने की आवश्यकता है जिसे हमने पहले बनाया था और इसे अपने डेटा के साथ प्रारंभ किया था। इंसर्टमैनी फ़ंक्शन के साथ, हमें सभी दस्तावेज़ों के लिए टाइप इंटरफ़ेस पास करना होगा।
ऑपरेशन पुनः प्राप्त करें
संग्रह से डेटा खोजने के लिए, हमें एक पास फ़िल्टर की आवश्यकता होगी, इसलिए सुनिश्चित करें कि आपने bson पैकेज आयात किया है। हम bson.D प्रकार का उपयोग bson ऑब्जेक्ट का उपयोग करके फ़िल्टर बनाने के लिए करेंगे।
func retrieveOne() {
var result Person
filter := bson.D{{"name", "Akash"}}
err := collection.FindOne(ctx, filter).Decode(&result)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Found a single document: %+v\n", result)
}उसी तरह, हम सभी मेल खाने वाले दस्तावेज़ों को पुनः प्राप्त करने के लिए Find विधि का उपयोग कर सकते हैं।
func retrieveAll() {
findOptions := options.Find()
findOptions.SetLimit(2)
var results []*Person
cur, err := collection.Find(ctx, bson.D{{}}, findOptions)
if err != nil {
log.Fatal(err)
}
// Loop through the cursor
for cur.Next(context.TODO()) {
var elem Person
err := cur.Decode(&elem)
if err != nil {
log.Fatal(err)
}
results = append(results, &elem)
}
if err := cur.Err(); err != nil {
log.Fatal(err)
}
cur.Close(context.TODO())
}आप विकल्प पैकेज का उपयोग सीमा या आदेश जैसे विकल्पों को निर्दिष्ट करने के लिए कर सकते हैं।
अपडेट ऑपरेशन
फाइनऑन विधि के समान, अपडेट के लिए भी आप bson फ़िल्टर ऑब्जेक्ट के साथ UpdateOne विधि का उपयोग कर सकते हैं। यह कोड आकाश नाम के सभी दस्तावेज़ों को अद्यतन करेगा और आयु के मान को एक से बढ़ा देगा।
func update() {
filter := bson.D{{"name", "Akash"}}
update := bson.D{
{"$inc", bson.D{
{"Age", 1},
}},
}
updateResult, err := collection.UpdateOne(context.TODO(), filter, update)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Updated documents: %+v\n", updateResult)
}ऑपरेशन हटाएं
किसी भी संग्रह से दस्तावेज़ हटाने के लिए, आप DeleteOne या DeleteMany पद्धति का उपयोग कर सकते हैं। यहां भी, हम दस्तावेज़ों से मिलान करने और उन्हें हटाने के लिए bson फ़िल्टर ऑब्जेक्ट पास कर सकते हैं।
func delete() {
deleteResult, err := collection.DeleteMany(ctx, bson.D{{}})
if err != nil {
log.Fatal(err)
}
fmt.Printf("Deleted %v documents in the trainers collection\n", deleteResult.DeletedCount)
}यदि आप bson.D{{}} ऑब्जेक्ट को फ़िल्टर पैरामीटर के रूप में पास करते हैं तो यह सभी दस्तावेज़ों को हटा देगा। आप पूरे संग्रह को छोड़ने के लिए संग्रह.ड्रॉप () पद्धति का उपयोग कर सकते हैं।
एक बार ये सभी फंक्शन तैयार हो जाने के बाद आप इन्हें अपनी जरूरत के हिसाब से अपने ड्राइवर फंक्शन में इस्तेमाल कर सकते हैं। उम्मीद है, यह आपको गो में MongoDB फ़ंक्शन लिखने के साथ आरंभ करने के लिए पर्याप्त होगा। अधिक जानकारी के लिए, आप गो मोंगो ड्राइवर के लिए आधिकारिक दस्तावेज देख सकते हैं।
