I mars 2019 släpptes den officiella, produktionsklara GO-drivrutinen för MongoDB och den har fått kontinuerliga uppdateringar från lanseringen. I den här handledningen kommer vi att lära oss att göra enkla MongoDB CRUD-operationer med Go-drivrutinen.
Förutsättningar
Två saker krävs innan vi börjar med den här handledningen.
- Go bör vara installerat på din dator. Go version 1.15 används för denna handledning. Du kan ladda ner Go-paketet från den här länken.
- Installera den senaste versionen av MongoDB på din dator och starta MongoDBs lokala server.
Installation av MongoDB-drivrutinen
Installera MongoDB go-drivrutinen genom att köra följande kommando:
go get go.mongodb.org/mongo-driverOm du använder Go-moduler, skapa en go.mod-fil och sedan kommer kommandot ovan att lägga till det nödvändiga beroendet i mod-filen. Den här filen låser alla projektkrav till korrekt version.
Konfigurera huvudfilen
Skapa en fil main.go i din projektmapp och öppna den i din IDE. Innan vi skriver koden för MongoDB-operationer, låt oss importera alla nödvändiga paket i filen.
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"
)Skapa nu följande globala variabler som vi kommer att använda för alla CRUD-operationsfunktioner.
var client *mongo.Client
var collection *mongo.Collection
var ctx = context.TODO()Skapa även strukturen för dokumenttyp.
type Person struct {
Name string
Age int
City string
}Ansluter till MongoDB
Nu är basinstallationen klar. Låt oss skapa vår första funktion för att ansluta till 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
}Denna funktion ställer in anslutningen till vår lokalt körda MongoDB och returnerar klientobjektet. När connect-metoden returnerar klientobjektet kan vi använda Ping()-metoden för att kontrollera om anslutningen lyckades eller inte. Om Ping()-metoden returnerar något fel, kan vi höja felet och returnera.
Infoga operation
För att bara infoga ett dokument kan vi använda metoden insertOne och för att infoga flera dokument tillsammans kan vi använda metoden insertMany. Följande är funktionen för att infoga ett dokument i personsamlingen:
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)
}Här är funktionen för att lägga till flera dokument till samlingen:
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)
}För båda operationerna måste vi använda Person struct som vi skapade tidigare och initialisera den med våra data. Med funktionen InsertMany måste vi passera typgränssnittet för alla dokument.
Hämta operation
För att hitta data från samlingen kommer vi att kräva ett passfilter så se till att du har importerat bson-paketet. Vi kommer att använda typen bson.D för att skapa filter med hjälp av bson-objekt.
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)
}På samma sätt kan vi använda sökmetoden för att hämta alla matchande dokument.
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())
}Du kan använda tillvalspaketet för att ange alternativ som gräns eller beställningar.
Uppdatera operation
Samma som FineOne-metoden, för uppdatering kan du också använda UpdateOne-metoden med bson filterobjekt. Den här koden kommer att uppdatera alla dokument med namnet Akash och öka värdet på Age med ett.
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)
}Ta bort operation
För att ta bort dokument från valfri samling kan du använda antingen DeleteOne- eller DeleteMany-metoden. Även här kan vi skicka bson-filterobjekt för att matcha dokumenten och ta bort dem.
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)
}Om du skickar bson.D{{}}-objektet som en filterparameter kommer det att radera alla dokument. Du kan använda metoden collection.Drop() för att ta bort hela samlingen.
När alla dessa funktioner är klara kan du använda dem i din förarfunktion efter dina behov. Förhoppningsvis kommer detta att räcka för att du ska komma igång med att skriva MongoDB-funktioner i Go. För mer information kan du se den officiella dokumentationen för Go Mongo-drivrutinen.