En mars 2019, le pilote GO officiel prêt pour la production pour MongoDB a été publié et il a reçu des mises à jour continues depuis son lancement. Dans ce didacticiel, nous allons apprendre à effectuer des opérations MongoDB CRUD simples à l'aide du pilote Go.
Prérequis
Deux choses sont nécessaires avant de commencer avec ce tutoriel.
- Go doit être installé sur votre machine. La version 1.15 de Go est utilisée pour ce didacticiel. Vous pouvez télécharger le package Go à partir de ce lien.
- Installez la dernière version de MongoDB sur votre machine et démarrez le serveur local de MongoDB.
Installation du pilote MongoDB
Installez le pilote MongoDB go en exécutant la commande suivante :
go get go.mongodb.org/mongo-driverSi vous utilisez des modules Go, créez un fichier go.mod, puis la commande ci-dessus ajoutera la dépendance requise dans le fichier mod. Ce fichier verrouille toutes les exigences du projet sur sa version correcte.
Configuration du fichier principal
Créez un fichier main.go dans votre dossier de projet et ouvrez-le dans votre IDE. Avant d'écrire le code des opérations MongoDB, importons tous les packages nécessaires dans le fichier.
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"
)Maintenant, créez les variables globales suivantes que nous utiliserons dans toutes les fonctions d'opération CRUD.
var client *mongo.Client
var collection *mongo.Collection
var ctx = context.TODO()Créez également la structure pour le type de document.
type Person struct {
Name string
Age int
City string
}Connexion à MongoDB
La configuration de base est maintenant prête. Créons notre première fonction pour se connecter à 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
}Cette fonction établira la connexion avec notre MongoDB exécuté localement et renverra l'objet client. Une fois que la méthode connect renvoie l'objet client, nous pouvons utiliser la méthode Ping() pour vérifier si la connexion a réussi ou non. Si la méthode Ping() renvoie une erreur, nous pouvons générer l'erreur et revenir.
Insérer une opération
Pour insérer un seul document, nous pouvons utiliser la méthode insertOne et pour insérer plusieurs documents ensemble, nous pouvons utiliser la méthode insertMany. Voici la fonction pour insérer un document dans la collection Person :
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)
}Voici la fonction pour ajouter plusieurs documents à la collection :
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)
}Pour les deux opérations, nous devons utiliser la structure Person que nous avons créée précédemment et l'initialiser avec nos données. Avec la fonction InsertMany, nous aurons besoin de passer le type interface pour tous les documents.
Opération de récupération
Pour trouver des données de la collection, nous aurons besoin d'un filtre de passage alors assurez-vous que vous avez importé le package bson. Nous utiliserons le type bson.D pour créer des filtres à l'aide d'objets 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)
}De la même manière, nous pouvons utiliser la méthode Find pour récupérer tous les documents correspondants.
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())
}Vous pouvez utiliser le package d'options pour spécifier des options telles que la limite ou les commandes.
Opération de mise à jour
Identique à la méthode FineOne, pour la mise à jour, vous pouvez également utiliser la méthode UpdateOne avec l'objet filtre bson. Ce code mettra à jour tous les documents avec le nom Akash et augmentera la valeur de l'âge de un.
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)
}Supprimer l'opération
Pour supprimer des documents de n'importe quelle collection, vous pouvez utiliser la méthode DeleteOne ou DeleteMany. Ici aussi, nous pouvons passer des objets de filtre bson pour faire correspondre les documents et les supprimer.
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)
}Si vous passez l'objet bson.D{{}} en tant que paramètre de filtre, tous les documents seront supprimés. Vous pouvez utiliser la méthode collection.Drop() pour supprimer toute la collection.
Une fois toutes ces fonctions prêtes, vous pouvez les utiliser dans votre fonction chauffeur selon votre besoin. J'espère que cela suffira pour vous permettre de commencer à écrire des fonctions MongoDB dans Go. Pour plus d'informations, vous pouvez vous référer à la documentation officielle du pilote Go Mongo.
