MongoDB gebruiken als gegevensbron in GoLang

Voordat u begint

Deze tutorial gaat ervan uit dat je het volgende hebt:

• Een basiskennis van Go Language
• Laatste GoLang-versie geïnstalleerd op uw systeem
• Laatste MongoDB-versie geïnstalleerd op uw systeem

In deze tutorial gebruiken we de officiële MongoDB Go Driver om onze MongoDB-database te beheren. Tijdens het proces zullen we een programma schrijven om te leren hoe de MongoDB Go Driver te installeren en er CRUD-bewerkingen mee uit te voeren.

Installatie

Voer eerst in een lege map het onderstaande commando uit

go mod init gomongo

go mod init maakt een nieuw go.mod-bestand aan en importeert automatisch afhankelijkheden wanneer u het go-programma uitvoert. Maak vervolgens het bestand main.go en schrijf de onderstaande code. We zullen in een minuut uitleggen wat deze code zal doen.

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

In de bovenstaande code hebben we de bson-, mongo- en mongo/options-pakketten van mongo-driver geïmporteerd en een Book gedefinieerd type dat in deze tutorial zal worden gebruikt

In de hoofdfunctie hebben we eerst clientOptions gemaakt met MongoDB-URL en inloggegevens en deze doorgegeven aan mongo.Connect functie, Eenmaal verbonden kunnen we onze verbinding controleren door client.Ping functie.

De volgende code gebruikt booksCollection variabele om de books te doorzoeken verzameling van testdb.

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

Documenten invoegen

Laten we eerst een boekstructuur maken om in de verzameling in te voegen, in onderstaande code gebruiken we collection.InsertOne functie om een ​​enkel document in de collectie in te voegen

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

Om meerdere documenten tegelijk in te voegen, moeten we een plak Book . maken object en geef het door aan 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)

Documenten bijwerken

We kunnen een enkel document bijwerken met de functie collection.UpdateOne . Het vereist een filterdocument dat overeenkomt met documenten in de verzameling en een bijgewerkt document om de updatebewerking te beschrijven. U kunt deze bouwen met behulp van bson.D-typen. De onderstaande code komt overeen met het boek met ISBN 0451526341 en verhoog het kopieerveld met 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.")