MongoDB Go Treiber Tutorial

Published on December 20, 2018

MongoDB Go Treiber Tutorial

UPD: Das Tutorial wurde aufgrund der Veröffentlichung der Release-Version aktualisiert.


Gute Nachrichten! Der offizielle Go-Treiber für mongoDB wurde veröffentlicht.
Nach einigem Überlegen habe ich beschlossen, den Artikel von der offiziellen mongoDB-Website zu übersetzen, anstatt das Material selbst zu schreiben (diese Übersetzung unterscheidet sich vom Artikel).
Folgendes wird in diesem Tutorial passieren:


  • Installieren Sie den Mongo-Go-Treiber
  • Verbindung zu mongoDB mit mongo-go-driver
  • Verwenden von BSON-Objekten
  • CRUD-Methoden verwenden

Bild


Den Originalcode finden Sie in der offiziellen Dokumentation .
Um mit diesem Handbuch arbeiten zu können, muss Version 2.6 oder höher auf MongoDB und Golang 1.10 oder höher installiert sein.


Installieren Sie den Mongo-Go-Treiber


Es wird empfohlen, den Treiber mit dep zu installieren (natürlich, wenn Sie noch nicht zu Modulen gewechselt haben):


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

Grundsteinlegung


Erstellen Sie ein Projekt und fügen Sie eine main.go- Datei mit folgendem Inhalt hinzu:


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
}

In diesem Code importieren wir Mongo-Go-Treiber, einige Standardbibliotheken und definieren den Typ Trainer.


Verbindung zu mongoDB mit mongo-go-driver


Nachdem wir mongo-go-driver importiert hatten, hatten wir die Möglichkeit, über die Funktion mongo.NewClient () eine Verbindung mit mongoDB herzustellen . Wir haben die Möglichkeit, die Kontextargumente und den String, der die Verbindungsadresse zu mongodb enthält, als Argumente an diese Funktion zu übergeben. Auf Wunsch können wir als drittes Argument auch ein options.ClientOptions- Objekt übergeben , um die Treiberoptionen zu optimieren .
In der Dokumentation sind die verfügbaren Optionen aufgeführt.


Fügen wir dem Hauptteil der Hauptfunktion den folgenden Code hinzu:


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

Nach erfolgreicher Verbindung mit mongoDB können wir auf die Trainer- Sammlung zugreifen , die sich in der Datenbank mit dem Namen test befindet, indem wir den folgenden Code am Ende der Hauptfunktion hinzufügen:


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

Es wird empfohlen, die Verbindung mit mongoDB offen zu halten, damit Sie die Verbindung nicht für jede Anforderung öffnen und schließen müssen. Wenn die Anwendung jedoch keine Verbindung mehr benötigt, kann sie mit der Funktion client.Disconnect () wie folgt geschlossen werden:


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

Kommentieren Sie nicht verwendete Pakete aus.


Führen Sie unseren Code aus ( rufen Sie main.go auf ), um die Verbindung zum mongoDB-Server zu überprüfen.


Verwenden von BSON-Einrichtungen


JSON-Dokumente in mongoDB werden in einem Binärformat namens BSON gespeichert. Im Gegensatz zu anderen Datenbanken, in denen JSON-Daten als Zeichenfolgen und Zahlen gespeichert sind, werden bei der BSON-Codierung neue Typen wie int , long , date , float und decimal128 hinzugefügt .


Dies vereinfacht die Verarbeitung, Sortierung und den Vergleich von Daten durch Anwendungen erheblich. Der Go-Treiber verfügt über zwei Arten von Familien zur Darstellung von BSON-Daten: Typen D und RAW-Typen.


Familie D besteht aus vier Typen:


  • D : BSON-Dokument. Dieser Typ sollte in Situationen verwendet werden, in denen die Reihenfolge wichtig ist, z. B. MongoDB-Befehle.
  • M : Ungeordnetes Wörterbuch (assoziatives Array, Karte). Es ist dasselbe wie D , außer dass es die Ordnung nicht beibehält.
  • A : BSON-Array.
  • E : einzelnes Element innerhalb d .

Hier ist ein Beispiel Filter , um den D-Typen aufgebaut verwenden, die eine Liste von Dokumenten , in denen produzieren die Feldnamen zu den Werten entsprechen Alice oder Bob :


Die Raw-Typenfamilie wird zum Überprüfen von Byte-Slices verwendet. Sie können einzelne Elemente mit Lookup () aus Raw-Typen extrahieren .


Dies kann nützlich sein, wenn Sie die zusätzliche Last beim Konvertieren von BSON in einen anderen Typ beseitigen müssen.
In diesem Lernprogramm wird nur die Familie der Typen D verwendet.


CRUD-Methoden verwenden


Nach erfolgreicher Verbindung mit der Datenbank können wir beginnen, Daten in unserer Sammlung hinzuzufügen und zu ändern.
Der Auflistungstyp enthält Methoden, mit denen Sie Anforderungen an die Datenbank senden können.


Dokumente einfügen (erstellen)


Zuerst müssen Sie mehrere neue Trainer- Strukturen erstellen , um sie in die Datenbank einzufügen:


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

Verwenden Sie die collection.InsertOne () -Methode, um ein einzelnes Dokument einzufügen :


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

Um mehrere Dokumente einzufügen, existiert gleichzeitig die Methode collection.InsertMany () :


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

Dokumentaktualisierung


Mit der collection.UpdateOne () -Methode können Sie ein einzelnes Dokument aktualisieren. Sie müssen einen Filter erstellen, um nach einem Dokument in der Datenbank und einem Dokument für den Aktualisierungsvorgang zu suchen. Sie können sie mit bson.D- Typen erstellen :


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

Der folgende Code findet ein Dokument, in dem der Feldname den Wert übereinstimmt Ash und den Wert erhöhen Alter 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)

Dokumentensuche


Um ein Dokument zu finden, benötigen Sie einen Filter sowie einen Zeiger auf eine Variable, in die das Ergebnis dekodiert werden kann.


Verwenden Sie collection.FindOne (), um ein einzelnes Dokument zu finden . Diese Methode gibt einen einzelnen Wert zurück, der in eine Variable decodiert werden kann.


Wir werden dieselbe Filtervariable verwenden, die in der Aktualisierungsanforderung verwendet wurde.


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

Verwenden Sie collection.Find (), um mehrere Dokumente zu finden .


Diese Methode gibt einen Cursor zurück . Cursor stellt einen Datenstrom von Dokumenten bereit, mit dem Sie jeweils ein Dokument durchlaufen und dekodieren können.


Wenn die Cursordokumente erschöpft sind, sollte der Cursor geschlossen sein . Der Cursor kann auch mithilfe des Optionspakets feinabgestimmt werden .


In unserem Beispiel haben wir die Ausgabe von zwei Dokumenten begrenzt.


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

Dokumente löschen


Sie können Dokumente mit collection.DeleteOne () oder collection.DeleteMany () löschen . Wir übergeben nil als Filterargument, das mit allen Dokumenten in der Sammlung übereinstimmt. Sie können auch collection.Drop () verwenden , um die gesamte Sammlung zu löschen.


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)

Die weitesten Schritte


→ Der endgültige Code für dieses Tutorial befindet sich im GitHub-Repository.
→ Die Treiberdokumentation ist in GoDoc verfügbar


Bei Fragen wenden Sie sich bitte an die Google Mongo-Go-Driver- Gruppe .
Bitte senden Sie Fehlerberichte an MongoDB JIRA .
Wir freuen uns über Ihr Feedback zu Go Driver.