Använder MongoDB som datakälla i GoLang

Innan du sätter igång

Denna handledning förutsätter att du har:

En grundläggande förståelse för Go Language
Senaste GoLang-versionen installerad på ditt system
Senaste MongoDB-versionen installerad på ditt system

I den här handledningen kommer vi att använda den officiella MongoDB Go-drivrutinen för att hantera vår MongoDB-databas. I den rätta processen kommer vi att skriva ett program för att lära oss hur man installerar MongoDB Go-drivrutinen och utför CRUD-operationer med den.

Installation

Kör först kommandot nedan i en tom mapp

go mod init gomongo

go mod init skapar en ny go.mod-fil och importerar automatiskt beroenden när du ska köra go-programmet. Skapa sedan filen main.go och skriv koden nedan. Vi kommer att förklara vad den här koden kommer att göra på en min.

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 ovanstående kod har vi importerat bson-, mongo- och mongo/options-paketen för mongo-driver och definierat en Book typ som kommer att användas i denna handledning

I huvudfunktionen skapade vi först clientOptions med MongoDB URL och referenser och skickade den till mongo.Connect funktion, när vi väl är anslutna kan vi kontrollera vår anslutning genom att client.Ping funktion.

Följande kod kommer att använda booksCollection variabel för att fråga books samling från testdb.

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

Infoga dokument

Låt oss först skapa en bokstruktur att infoga i samlingen, i koden nedan använder vi collection.InsertOne funktion för att infoga ett enda 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)

För att infoga flera dokument samtidigt måste vi skapa en del av Book objekt och skicka det till 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)

Uppdatera dokument

Vi kan uppdatera ett enda dokument med funktionen collection.UpdateOne . Det kräver ett filterdokument för att matcha dokument i samlingen och ett uppdaterat dokument för att beskriva uppdateringsoperationen. Du kan bygga dessa med bson.D-typer. Koden nedan kommer att matcha boken med ISBN 0451526341 och öka fältet kopior 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)

Du kan också uppdatera mer än ett dokument samtidigt i en enda samling med funktionen collection.UpdateMany , I den måste vi skicka filterdokument och uppdatera dokument på samma sätt som collection.UpdateOne

Hitta dokument

För att hitta ett enskilt dokument kan vi använda funktionen collection.FindOne() , skickar vi ett filterdokument och avkodar resultatet i Book typ variabel

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

För att hitta flera dokument använder vi funktionen collection.Find() . Den här metoden returnerar en markör, den tillhandahåller en ström av dokument som vi kan iterera på eller så kan vi hämta alla dokument med funktionen cursor.All() i en bit av Book typ.

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)

Ta bort dokument

Vi kan ta bort dokument från en samling med funktionerna collection.DeleteOne() eller collection.DeleteMany() . Här skickar du bson.D{{}} som filterargument, vilket kommer att matcha alla dokument i samlingen.

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)

Hela samlingen kan tas bort med funktionen collection.Drop(), den tar bort alla dokument och metadata, såsom index från samlingen

När du har gjort alla operationer, glöm inte att stänga MongoDB-anslutningen

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

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

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

Nu kan du enkelt använda MongoDB som datakälla i din go-applikation. Du kan hitta hela koden som används i denna handledning på vår Github Repo