Verwendung von MongoDB als Datenquelle in GoLang

Bevor Sie beginnen

Dieses Tutorial setzt Folgendes voraus:

• Ein grundlegendes Verständnis der Go-Sprache
• Neueste GoLang-Version auf Ihrem System installiert
• Neueste auf Ihrem System installierte MongoDB-Version

In diesem Tutorial verwenden wir den offiziellen MongoDB Go-Treiber zur Verwaltung unserer MongoDB-Datenbank. Im Laufe des Prozesses werden wir ein Programm schreiben, um zu lernen, wie man den MongoDB Go-Treiber installiert und damit CRUD-Operationen durchführt.

Installation

Führen Sie zuerst in einem leeren Ordner den folgenden Befehl aus

go mod init gomongo

go mod init erstellt eine neue go.mod-Datei und importiert automatisch Abhängigkeiten, wenn Sie das go-Programm ausführen. Erstellen Sie dann die Datei main.go und schreiben Sie den folgenden Code. Wir werden in einer Minute erklären, was dieser Code tun wird.

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

Im obigen Code haben wir die Pakete bson, mongo und mongo/options von mongo-driver importiert und ein Book definiert Typ, der in diesem Tutorial verwendet wird

In der Hauptfunktion haben wir zuerst clientOptions mit MongoDB-URL und Anmeldeinformationen erstellt und an mongo.Connect übergeben Funktion, Sobald wir verbunden sind, können wir unsere Verbindung mit client.Ping überprüfen Funktion.

Der folgende Code verwendet booksCollection Variable zum Abfragen der books Sammlung von testdb.

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

Dokumente einfügen

Lassen Sie uns zuerst eine Book-Struktur erstellen, die in die Sammlung eingefügt werden soll. Im folgenden Code verwenden wir collection.InsertOne Funktion zum Einfügen eines einzelnen Dokuments in die Sammlung

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

Um mehrere Dokumente gleichzeitig einzufügen, müssen wir ein Segment von Book erstellen Objekt und übergeben Sie es an 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)

Dokumente aktualisieren

Wir können ein einzelnes Dokument mit der Funktion collection.UpdateOne aktualisieren . Es erfordert ein Filterdokument, um Dokumente in der Sammlung abzugleichen, und ein aktualisiertes Dokument, um den Aktualisierungsvorgang zu beschreiben. Sie können diese mit bson.D-Typen erstellen. Der folgende Code stimmt mit dem Buch mit ISBN überein 0451526341 und erhöhen Sie das Kopienfeld um 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)

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

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)

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)

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

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

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