Tutoriel du pilote MongoDB Go

UPD: le tutoriel a été mis à jour en lien avec la sortie de la version finale.

Bonne nouvelle! Le pilote officiel go pour mongoDB a été libéré.
Avec un peu de réflexion, j'ai décidé de traduire l' article à partir du site officiel de mongoDB au lieu d'écrire le matériel moi-même (cette traduction est différente de l'article).
Voici ce qui sera dans ce tutoriel:

• Installer mongo-go-driver
• Connectez-vous à mongoDB à l'aide de mongo-go-driver
• Utilisation d'objets BSON
• Utilisation des méthodes CRUD

Le code d'origine se trouve dans la documentation officielle .
Pour utiliser ce guide, vous devez avoir installé la version de MongoDB non inférieure à 2.6 et Golang 1.10 ou ultérieure.

Installer mongo-go-driver

Il est recommandé d'installer le pilote à l'aide de dep (bien sûr, si vous n'avez toujours pas basculé vers les modules):

dep ensure -add "go.mongodb.org/mongo-driver/mongo@~1.0.0" 

Création de fondation

Créez un projet et ajoutez le fichier main.go avec le contenu suivant:

 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" "go.mongodb.org/mongo-driver/mongo/readpref" ) // You will be using this Trainer type later in the program type Trainer struct { Name string Age int City string } func main() { // Rest of the code will go here } 

Dans ce code, nous importons mongo-go-driver, quelques bibliothèques standard et définissons le type Trainer.

Connectez-vous à mongoDB à l'aide de mongo-go-driver

Après avoir importé le pilote mongo-go, nous avons eu la possibilité de créer une connexion avec mongoDB à l'aide de la fonction mongo.NewClient () . Nous avons l'occasion de passer à cette fonction comme arguments le contexte et la ligne contenant l'adresse de la connexion à mongodb. Si vous le souhaitez, nous pouvons également passer l'objet options.ClientOptions comme troisième argument pour affiner les paramètres du pilote.
La documentation détaille les options disponibles.

Ajoutons le code suivant au corps de la fonction principale:

 // Create client client, err := mongo.NewClient(options.Client().ApplyURI("mongodb://127.0.0.1:27017")) if err != nil { log.Fatal(err) } // Create connect err = client.Connect(context.TODO()) 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!") 

Après une connexion réussie à mongoDB, nous pouvons accéder à la collection trainers , qui se trouve dans la base de données appelée test en ajoutant le code suivant à la fin de la fonction principale:

 collection := client.Database("test").Collection("trainers") 

Il est recommandé de garder la connexion avec mongoDB ouverte afin de ne pas avoir à ouvrir et fermer la connexion pour chaque demande. Cependant, si l'application ne nécessite plus de connexion, elle peut être fermée à l'aide de la fonction client.Disconnect () comme suit:

 err = client.Disconnect(context.TODO()) if err != nil { log.Fatal(err) } fmt.Println("Connection to MongoDB closed.") 

Commentez les packages inutilisés.

Exécutez notre code ( allez exécuter main.go ) pour vérifier la connexion au serveur mongoDB.

Utilisation d'objets BSON

Les documents JSON dans mongoDB sont stockés dans un format binaire appelé BSON. Contrairement à d'autres bases de données dans lesquelles les données JSON sont stockées sous forme de chaînes et de nombres, le codage BSON ajoute de nouveaux types, tels que int , long , date , float et decimal128 .

Cela simplifie considérablement le traitement, le tri et la comparaison des données par les applications. Le pilote Go a deux familles de types pour représenter les données BSON: les types D et les types RAW.

La famille D se compose de quatre types:

• D : document BSON. Ce type doit être utilisé dans les situations où l'ordre est important, par exemple, les commandes MongoDB.
• M : dictionnaire non ordonné (tableau associatif, carte). C'est la même chose que D , sauf qu'il ne préserve pas l'ordre.
• A : tableau BSON.
• E : élément unique à l'intérieur de D.

Voici un exemple de filtre construit à l'aide de types D qui recherche des documents dans lesquels le champ de nom correspond aux valeurs d' Alice ou de Bob :

La famille de type Raw est utilisée pour vérifier le découpage d'octets. Vous pouvez extraire des éléments uniques de types Raw à l'aide de Lookup () .

Cela peut être utile lorsque vous devez vous débarrasser de la charge supplémentaire lors de la conversion de BSON en un autre type.
Seule la famille de type D sera utilisée dans ce didacticiel.

Utilisation des méthodes CRUD

Après une connexion réussie à la base de données, nous pouvons commencer à ajouter et à modifier des données dans notre collection.
Le type Collection contient des méthodes qui vous permettent d'envoyer des requêtes à la base de données.

Insertion (création) de documents

Vous devez d'abord créer de nouvelles structures de formateur à insérer dans la base de données:

 ash := Trainer{"Ash", 10, "Pallet Town"} misty := Trainer{"Misty", 10, "Cerulean City"} brock := Trainer{"Brock", 15, "Pewter City"} 

Pour incorporer un seul document, utilisez la méthode collection.InsertOne () :

 insertResult, err := collection.InsertOne(context.TODO(), ash) if err != nil { log.Fatal(err) } fmt.Println("Inserted a single document: ", insertResult.InsertedID) 

Pour insérer plusieurs documents en même temps, la méthode collection.InsertMany () existe:

 trainers := []interface{}{misty, brock} insertManyResult, err := collection.InsertMany(context.TODO(), trainers) if err != nil { log.Fatal(err) } fmt.Println("Inserted multiple documents: ", insertManyResult.InsertedIDs) 

Mise à jour du document

La méthode collection.UpdateOne () vous permet de mettre à jour un seul document. Vous devez créer un filtre pour rechercher un document dans la base de données et un document pour l'opération de mise à jour. Vous pouvez les créer en utilisant les types bson.D :

 filter := bson.D{{"name", "Ash"}} update := bson.D{ {"$inc", bson.D{ {"age", 1}, }}, } 

Le code suivant trouvera un document dans lequel le champ de nom correspond à la valeur Ash et incrémente la valeur d' âge de 1.

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

Recherche de documents

Pour trouver un document, vous aurez besoin d'un filtre, ainsi que d'un pointeur vers une variable dans laquelle le résultat peut être décodé.

Pour rechercher un seul document, utilisez collection.FindOne () . Cette méthode renvoie une valeur unique qui peut être décodée en une variable.

Nous utiliserons la même variable de filtre que celle utilisée dans la demande de mise à jour.

 // create a value into which the result can be decoded var result Trainer err = collection.FindOne(context.TODO(), filter).Decode(&result) if err != nil { log.Fatal(err) } fmt.Printf("Found a single document: %+v\n", result) 

Pour rechercher plusieurs documents, utilisez collection.Find () .

Cette méthode renvoie le curseur . Le curseur fournit un flux de documents avec lequel vous pouvez parcourir et décoder un document à la fois.

Lorsque les documents dans Cursor sont épuisés, vous devez fermer Cursor . Vous pouvez également affiner le curseur à l'aide du package d' options .

Dans notre exemple, nous avons fixé une limite à la délivrance de deux documents.

 // Pass these options to the Find method options := options.Find() options.SetLimit(2) filter := bson.M{} // Here's an array in which you can store the decoded documents var results []*Trainer // Passing nil as the filter matches all documents in the collection cur, err := collection.Find(context.TODO(), filter, options) if err != nil { log.Fatal(err) } // Finding multiple documents returns a cursor // Iterating through the cursor allows us to decode documents one at a time for cur.Next(context.TODO()) { // create a value into which the single document can be decoded var elem Trainer err := cur.Decode(&elem) if err != nil { log.Fatal(err) } results = append(results, &elem) } if err := cur.Err(); err != nil { log.Fatal(err) } // Close the cursor once finished cur.Close(context.TODO()) fmt.Printf("Found multiple documents (array of pointers): %+v\n", results) 

Supprimer des documents

Vous pouvez supprimer des documents à l'aide de collection.DeleteOne () ou collection.DeleteMany () . Nous passons nil comme argument de filtre, qui correspondra à tous les documents de la collection. Vous pouvez également utiliser collection.Drop () pour supprimer la collection entière.

 filter := bson.M{} deleteResult, err := collection.DeleteMany(context.TODO(), filter) if err != nil { log.Fatal(err) } fmt.Printf("Deleted %v documents in the trainers collection\n", deleteResult.DeletedCount) 

Etapes supplémentaires

→ Le code final de ce tutoriel est dans le référentiel GitHub
→ Documentation du pilote disponible dans GoDoc

Si vous avez des questions, veuillez nous contacter dans le groupe google mongo-go-driver .
Veuillez envoyer les rapports de bogues à MongoDB JIRA .
Nous serons heureux de recevoir vos commentaires sur Go Driver.