Geekly articles weekly

MongoDB Go Treiber Tutorial

UPD: Das Tutorial wurde im Zusammenhang mit der Veröffentlichung der Release-Version aktualisiert.


Gute Neuigkeiten! Der offizielle Go-Treiber für mongoDB wurde veröffentlicht.
Mit ein wenig Nachdenken habe ich beschlossen, den Artikel von der offiziellen mongoDB-Website zu übersetzen, anstatt das Material selbst zu schreiben (diese Übersetzung unterscheidet sich vom Artikel).
In diesem Tutorial wird Folgendes beschrieben:


  • Installieren Sie den Mongo-Go-Treiber
  • Stellen Sie mit dem Mongo-Go-Treiber eine Verbindung zu mongoDB her
  • Verwenden von BSON-Objekten
  • Verwenden von CRUD-Methoden

Bild


Den Originalcode finden Sie in der offiziellen Dokumentation .
Um dieses Handbuch verwenden zu können, müssen Sie MongoDB Version 2.6 oder höher und Golang 1.10 oder höher installiert haben.


Installieren Sie den Mongo-Go-Treiber


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


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

Gründung der Stiftung


Erstellen Sie ein Projekt und fügen Sie die Datei main.go mit den folgenden Inhalten 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.


Stellen Sie mit dem Mongo-Go-Treiber eine Verbindung zu mongoDB her


Nachdem wir den mongo-go-Treiber importiert hatten, hatten wir die Möglichkeit, mit der Funktion mongo.NewClient () eine Verbindung mit mongoDB herzustellen . Wir haben die Möglichkeit, als Funktion den Kontext und die Zeile mit der Adresse der Verbindung zu mongodb an diese Funktion zu übergeben. Auf Wunsch können wir auch das Objekt options.ClientOptions als drittes Argument zur Feinabstimmung der Treibereinstellungen übergeben.
In der Dokumentation werden die verfügbaren Optionen beschrieben.


Fügen wir dem Hauptfunktionskörper 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 Trainersammlung zugreifen, die sich in der Datenbank mit dem Namen test befindet, indem wir am Ende der Hauptfunktion den folgenden Code 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.")

Nicht verwendete Pakete auskommentieren.


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


Verwenden von BSON-Objekten


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


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


Familie D besteht aus vier Typen:


  • D : BSON-Dokument. Dieser Typ sollte in Situationen verwendet werden, in denen die Reihenfolge von Bedeutung ist, z. B. bei MongoDB-Befehlen.
  • M : Ungeordnetes Wörterbuch (assoziatives Array, Karte). Es ist dasselbe wie D , außer dass die Ordnung nicht erhalten bleibt.
  • A : BSON-Array.
  • E : einzelnes Element in D.

Hier ist ein Beispiel für einen Filter, der mit D-Typen erstellt wurde und nach Dokumenten sucht, in denen das Namensfeld mit den Werten von Alice oder Bob übereinstimmt:


Die Raw-Typfamilie wird verwendet, um nach Byte-Slicing zu suchen. 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 D-Typ-Familie verwendet.


Verwenden von CRUD-Methoden


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 Abfragen an die Datenbank senden können.


Einfügen (Erstellen) von Dokumenten


Zuerst müssen Sie einige 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 Methode collection.InsertOne (), um ein einzelnes Dokument einzubetten:


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

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


 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 den Typen bson.D erstellen:


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

Der folgende Code findet ein Dokument, in dem das Namensfeld mit dem Wert von Ash übereinstimmt und den Wert des Alters um 1 erhöht.


 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 dekodiert 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 den Cursor zurück . Der Cursor bietet einen Dokumentstrom, mit dem Sie jeweils ein Dokument iterieren und dekodieren können.


Wenn die Dokumente im Cursor erschöpft sind, sollten Sie den Cursor schließen . Sie können den Cursor auch mithilfe des Optionspakets optimieren.


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)

Weitere Schritte


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


Wenn Sie Fragen haben, kontaktieren Sie uns bitte in der Google- Gruppe Mongo-Go-Treiber .
Bitte senden Sie Fehlerberichte an MongoDB JIRA .
Wir freuen uns über Ihr Feedback zu Go Driver.

Source: https://habr.com/ru/post/de433776/

More articles:


All Articles