Brug af MongoDB som datakilde i GoLang

Før du går i gang

Denne vejledning antager, at du har:

• En grundlæggende forståelse af Go Language
• Seneste GoLang-version installeret på dit system
• Seneste MongoDB-version installeret på dit system

I denne vejledning vil vi bruge den officielle MongoDB Go-driver at administrere vores MongoDB-database. I den rette proces vil vi skrive et program for at lære, hvordan man installerer MongoDB Go-driveren og udfører CRUD-operationer med den.

Installation

Kør først nedenstående kommando

go mod init gomongo

go mod init opretter en ny go.mod-fil og importerer automatisk afhængigheder, når du vil køre go-programmet. Opret derefter filen main.go og skriv nedenstående kode. Vi vil forklare, hvad denne kode vil gøre på et minut.

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

I ovenstående kode har vi importeret bson-, mongo- og mongo/options-pakkerne af mongo-driver og defineret en Book type, som vil blive brugt i denne øvelse

I hovedfunktionen oprettede vi først clientOptions med MongoDB URL og legitimationsoplysninger og videregiver det til mongo.Connect funktion, når vi først er tilsluttet, kan vi kontrollere vores forbindelse ved at client.Ping funktion.

Følgende kode vil bruge booksCollection variabel for at forespørge books samling fra testdb.

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

Indsæt dokumenter

Lad os først oprette en bogstruktur til at indsætte i samlingen, i koden nedenfor bruger vi collection.InsertOne funktion til at indsætte et enkelt dokument i samlingen

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

For at indsætte flere dokumenter på én gang skal vi oprette et udsnit af Book objekt og send det til 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)

Opdater dokumenter

Vi kan opdatere et enkelt dokument med funktionen collection.UpdateOne . Det kræver et filterdokument for at matche dokumenter i samlingen og et opdateret dokument til at beskrive opdateringshandlingen. Du kan bygge disse ved hjælp af bson.D-typer. Nedenstående kode vil matche bogen med ISBN 0451526341 og forøg kopifeltet med 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.")