MongoDB
 sql >> Base de données >  >> NoSQL >> MongoDB

Utilisation de MongoDB comme source de données dans GoLang

Avant de commencer

Ce didacticiel suppose que vous avez :

  • Une compréhension de base du langage Go
  • Dernière version de GoLang installée sur votre système
  • Dernière version de MongoDB installée sur votre système

Dans ce tutoriel, nous utiliserons le pilote MongoDB Go officiel pour gérer notre base de données MongoDB. Dans le cadre de la procédure régulière, nous écrirons un programme pour apprendre à installer le pilote MongoDB Go et à effectuer des opérations CRUD avec.

Installation

D'abord dans un dossier vide, exécutez la commande ci-dessous

go mod init gomongo

go mod init crée un nouveau fichier go.mod et importe automatiquement les dépendances lorsque vous exécuterez le programme go. Créez ensuite le fichier main.go et écrivez le code ci-dessous, nous vous expliquerons ce que ce code fera en une minute.

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"
)

// Book - We will be using this Book type to perform crud operations
type Book struct {
  Title     string
  Author    string
  ISBN      string
  Publisher string
  Copies     int
}

func main() {
    
  // Set client options
  clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")

  // Connect to MongoDB
  client, err := mongo.Connect(context.TODO(), clientOptions)

  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!")
  booksCollection := client.Database("testdb").Collection("books")
}

Dans le code ci-dessus, nous avons importé les packages bson, mongo et mongo/options de mongo-driver et défini un Book type qui sera utilisé dans ce tutoriel

Dans la fonction principale, nous avons d'abord créé clientOptions avec l'URL et les informations d'identification de MongoDB et les avons transmises à mongo.Connect fonction, Une fois connecté, nous pouvons vérifier notre connexion par client.Ping fonction.

Le code suivant utilisera booksCollection variable pour interroger les books collection de testdb.

booksCollection := client.Database("testdb").Collection("books")

Insérer des documents

Commençons par créer une structure Book à insérer dans la collection, dans le code ci-dessous, nous utilisons collection.InsertOne fonction pour insérer un seul document dans la collection

// Insert One document
book1 := Book{"Animal Farm", "George Orwell", "0451526341", "Signet Classics", 100}
insertResult, err := booksCollection.InsertOne(context.TODO(), book1)
if err != nil {
    log.Fatal(err)
}

fmt.Println("Inserted a single document: ", insertResult.InsertedID)

Pour insérer plusieurs documents à la fois, nous devons créer une tranche de Book objet et transmettez-le à collection.InsertMany 

// Insert multiple documents
book2 := Book{"Super Freakonomics", "Steven D. Levitt", "0062312871", "HARPER COLLINS USA", 100}
book3 := Book{"The Alchemist", "Paulo Coelho", "0062315005", "HarperOne", 100}
multipleBooks := []interface{}{book2, book3}

insertManyResult, err := booksCollection.InsertMany(context.TODO(), multipleBooks)
if err != nil {
    log.Fatal(err)
}

fmt.Println("Inserted multiple documents: ", insertManyResult.InsertedIDs)

Mettre à jour les documents

Nous pouvons mettre à jour un seul document par la fonction collection.UpdateOne . Il nécessite un document de filtre pour faire correspondre les documents de la collection et un document mis à jour pour décrire l'opération de mise à jour. Vous pouvez les construire en utilisant les types bson.D. Le code ci-dessous correspondra au livre avec ISBN 0451526341 et incrémentez le champ copies de 10 

//Update one document
filter := bson.D{{"isbn", "0451526341"}}

update := bson.D{
    {"$inc", bson.D{
        {"copies", 10},
    }},
}

updateResult, err := booksCollection.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)

Vous pouvez également mettre à jour plusieurs documents à la fois dans une seule collection par la fonction collection.UpdateMany , Dans celui-ci, nous devons passer le document filtre et mettre à jour le document comme collection.UpdateOne

Rechercher des documents

Pour trouver un seul document, nous pouvons utiliser la fonction collection.FindOne() , nous passerons un document filtre et décoderons le résultat dans le Book saisir une variable

// A variable in which result will be decoded
var result Book

err = booksCollection.FindOne(context.TODO(), filter).Decode(&result)
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Found a single document: %+v\n", result)

Pour trouver plusieurs documents, nous utilisons la fonction collection.Find() . Cette méthode renvoie un curseur, elle fournit un flux de documents sur lequel nous pouvons itérer ou nous pouvons obtenir tous les documents par la fonction cursor.All() dans une tranche de Book taper. 

cursor, err := booksCollection.Find(context.TODO(), bson.D{{}})
if err != nil {
  log.Fatal(err)
}
var books []Book
if err = cursor.All(context.TODO(), &books); err != nil {
  log.Fatal(err)
}
fmt.Printf("Found multiple documents: %+v\n", books)

Supprimer des documents

Nous pouvons supprimer des documents d'une collection en utilisant les fonctions collection.DeleteOne() ou collection.DeleteMany() . Ici, vous passez bson.D{{}} comme argument de filtre, qui correspondra à tous les documents de la collection.

deleteCollection, err := booksCollection.DeleteMany(context.TODO(), bson.D{{}})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Deleted %v documents in the books collection\n", deleteCollection.DeletedCount)

Toute la collection peut être supprimée à l'aide de la fonction collection.Drop(), elle supprimera tous les documents et métadonnées, tels que les index de la collection

Une fois que vous avez effectué toutes les opérations, n'oubliez pas de fermer la connexion MongoDB

err = client.Disconnect(context.TODO())

if err != nil {
    log.Fatal(err)
}

fmt.Println("Connection to MongoDB closed.")

Maintenant, vous pouvez facilement utiliser MongoDB comme source de données dans votre application go, vous pouvez trouver le code complet utilisé dans ce tutoriel sur notre Github Repo