I marts 2019 blev den officielle, produktionsklare GO-driver til MongoDB frigivet, og den har modtaget løbende opdateringer fra lanceringen. I denne øvelse lærer vi at udføre simple MongoDB CRUD-operationer ved hjælp af Go-driver.
Forudsætninger
To ting kræves, før vi starter med denne øvelse.
- Go skal være installeret på din maskine. Go version 1.15 bruges til denne øvelse. Du kan downloade Go-pakken fra dette link.
- Installer den seneste version af MongoDB på din maskine og start MongoDBs lokale server.
Installation af MongoDB-driveren
Installer MongoDB go-driveren ved at køre følgende kommando:
go get go.mongodb.org/mongo-driverHvis du bruger Go-moduler, så opret en go.mod-fil, og så tilføjer ovenstående kommando den nødvendige afhængighed i mod-filen. Denne fil låser alle projektkrav til dens korrekte version.
Opsætning af hovedfilen
Opret en fil main.go i din projektmappe og åbn den i din IDE. Før vi skriver koden til MongoDB-operationer, lad os importere alle de nødvendige pakker 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"
)Opret nu følgende globale variabler, som vi vil bruge på tværs af alle CRUD-operationsfunktionerne.
var client *mongo.Client
var collection *mongo.Collection
var ctx = context.TODO()Opret også strukturen for dokumenttype.
type Person struct {
Name string
Age int
City string
}Opretter forbindelse til MongoDB
Nu er basisopsætningen klar. Lad os oprette vores første funktion til at oprette forbindelse til 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
}Denne funktion opsætter forbindelsen til vores lokalt kørende MongoDB og returnerer klientobjektet. Når først forbindelsesmetoden returnerer klientobjektet, kan vi bruge Ping()-metoden til at kontrollere, om forbindelsen var vellykket eller ej. Hvis Ping()-metoden returnerer en fejl, kan vi hæve fejlen og returnere.
Indsæt handling
For kun at indsætte ét dokument, kan vi bruge insertOne-metoden og for at indsætte flere dokumenter sammen, kan vi bruge insertMany-metoden. Følgende er funktionen til at indsætte ét 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)
}Her er funktionen til at tilføje flere dokumenter til 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)
}For begge operationer skal vi bruge Person struct, som vi oprettede tidligere, og initialisere den med vores data. Med funktionen InsertMany skal vi bestå typegrænsefladen for alle dokumenter.
Hent handling
For at finde data fra samlingen kræver vi et pass-filter, så sørg for at du har importeret bson-pakken. Vi vil bruge typen bson.D til at oprette filtre ved hjælp af bson-objekter.
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å samme måde kan vi bruge Find-metoden til at hente alle de matchende dokumenter.
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 bruge indstillingspakken til at angive muligheder som grænse eller ordrer.
Opdater handling
Samme som FineOne-metoden, til opdatering kan du også bruge UpdateOne-metoden med bson filterobjekt. Denne kode vil opdatere alle dokumenter med navnet Akash og øge værdien af Alder med én.
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)
}Slet handling
For at slette dokumenter fra enhver samling kan du bruge enten DeleteOne- eller DeleteMany-metoden. Også her kan vi sende bson-filterobjekter til at matche dokumenterne og slette 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)
}Hvis du sender bson.D{{}} objekt som en filterparameter, vil det slette alle dokumenter. Du kan bruge metoden collection.Drop() til at slette hele samlingen.
Når alle disse funktioner er klar, kan du bruge dem i din driverfunktion efter dit behov. Forhåbentlig vil dette være nok til at få dig i gang med at skrive MongoDB-funktioner i Go. For mere information kan du henvise til den officielle dokumentation for Go Mongo-driveren.